1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package net.sourceforge.pmd.lang.plsql.ast;
21
22 import java.io.*;
23 import net.sourceforge.pmd.lang.ast.Node;
24 import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25 import net.sourceforge.pmd.lang.ast.TokenMgrError;
26
27 public class PLSQLParserimplements PLSQLParserTreeConstants, PLSQLParserConstants {
28 protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29
30
31
32
33 public static void main(String[] args)
34 throws ParseException {
35
36 PLSQLParser parser = new PLSQLParser(System.in);
37 PLSQLNode node = parser.Input();
38
39 String s;
40 s = "qwerty";
41
42 s = "\u005c"qwerty\u005c"";
43
44 s = "\u005c"qwerty\u005c".uiop";
45
46 s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47
48 }
49
50
51
52
53 public static String canonicalName(String name)
54 {
55 StringBuilder s = null ;
56
57
58 if (null == name) {
59 return name;
60 }
61 else if (-1 == name.indexOf('"') )
62 {
63 name = name.toUpperCase();
64 s = new StringBuilder(name.trim());
65 }
66 else
67 {
68 StringBuilder oldString = new StringBuilder( name.trim().length());
69 s = new StringBuilder(name.trim());
70 boolean quotedCharacter = false ;
71 for (int i=0; i<oldString.length(); i++) {
72 if (oldString.charAt(i) == '"')
73 {
74
75 oldString.deleteCharAt(i);
76 i--;
77
78
79 quotedCharacter = !quotedCharacter ;
80 }
81 else
82 {
83 s.append( quotedCharacter
84 ? s.charAt(i)
85 : Character.toUpperCase(s.charAt(i))
86 );
87 }
88 }
89 }
90 return s.toString();
91 }
92
93
94
95
96
97
98
99
100
101
102
103 final public ASTInput Input() throws ParseException {
104
105 ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106 boolean jjtc000 = true;
107 jjtree.openNodeScope(jjtn000);
108 try {
109 label_1:
110 while (true) {
111 switch (jj_nt.kind) {
112 case 2:
113 case 3:
114 case 21:
115 case ALTER:
116 case BEGIN:
117 case COLUMN:
118 case COMMENT:
119 case COMMIT:
120 case CONNECT:
121 case CREATE:
122 case DECLARE:
123 case DELETE:
124 case DROP:
125 case EXECUTE:
126 case EXIT:
127 case FUNCTION:
128 case GRANT:
129 case INSERT:
130 case LOCK:
131 case MERGE:
132 case PACKAGE:
133 case PROMPT:
134 case PROCEDURE:
135 case RENAME:
136 case REVOKE:
137 case ROLLBACK:
138 case SAVEPOINT:
139 case SELECT:
140 case SET:
141 case START:
142 case TRIGGER:
143 case TYPE:
144 case SHOW:
145 case SPOOL:
146 case UPDATE:
147 case WITH:
148 case ANALYZE:
149 case ASSOCIATE:
150 case AUDIT:
151 case DDL:
152 case DISASSOCIATE:
153 case NOAUDIT:
154 case TRUNCATE:
155 case ACCEPT:
156 case COPY:
157 case DEFINE:
158 case DISCONNECT:
159 case HOST:
160 case PRINT:
161 case QUIT:
162 case REMARK:
163 case UNDEFINE:
164 case VARIABLE:
165 case WHENEVER:
166 case IDENTIFIER:
167 ;
168 break;
169 default:
170 jj_la1[0] = jj_gen;
171 break label_1;
172 }
173 if (jj_2_1(7)) {
174 PackageSpecification();
175 } else if (jj_2_2(7)) {
176 PackageBody();
177 } else if (jj_2_3(6)) {
178 TypeSpecification();
179 } else if (jj_2_4(6)) {
180 Table();
181 } else if (jj_2_5(6)) {
182 View();
183 } else if (jj_2_6(6)) {
184 TriggerUnit();
185 } else if (jj_2_7(6)) {
186 AlterTrigger();
187 } else if (jj_2_8(6)) {
188 Synonym();
189 } else if (jj_2_9(6)) {
190 Directory();
191 } else if (jj_2_10(6)) {
192 DatabaseLink();
193 } else if (jj_2_11(6)) {
194 Global();
195 } else if (jj_2_12(6)) {
196 DDLCommand();
197 } else if (jj_2_13(2)) {
198 SqlPlusCommand();
199 } else {
200 switch (jj_nt.kind) {
201 case COMMIT:
202 case DELETE:
203 case INSERT:
204 case LOCK:
205 case MERGE:
206 case ROLLBACK:
207 case SAVEPOINT:
208 case SELECT:
209 case UPDATE:
210 case WITH:
211 switch (jj_nt.kind) {
212 case SELECT:
213 jj_consume_token(SELECT);
214 break;
215 case UPDATE:
216 jj_consume_token(UPDATE);
217 break;
218 case INSERT:
219 jj_consume_token(INSERT);
220 break;
221 case DELETE:
222 jj_consume_token(DELETE);
223 break;
224 case COMMIT:
225 jj_consume_token(COMMIT);
226 break;
227 case ROLLBACK:
228 jj_consume_token(ROLLBACK);
229 break;
230 case SAVEPOINT:
231 jj_consume_token(SAVEPOINT);
232 break;
233 case LOCK:
234 jj_consume_token(LOCK);
235 jj_consume_token(TABLE);
236 break;
237 case MERGE:
238 jj_consume_token(MERGE);
239 break;
240 case WITH:
241 jj_consume_token(WITH);
242 break;
243 default:
244 jj_la1[1] = jj_gen;
245 jj_consume_token(-1);
246 throw new ParseException();
247 }
248 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249 break;
250 default:
251 jj_la1[2] = jj_gen;
252 jj_consume_token(-1);
253 throw new ParseException();
254 }
255 }
256 label_2:
257 while (true) {
258 switch (jj_nt.kind) {
259 case 1:
260 ;
261 break;
262 default:
263 jj_la1[3] = jj_gen;
264 break label_2;
265 }
266 jj_consume_token(1);
267 }
268 }
269 jj_consume_token(0);
270 jjtree.closeNodeScope(jjtn000, true);
271 jjtc000 = false;
272 {if (true) return jjtn000 ;}
273 } catch (Throwable jjte000) {
274 if (jjtc000) {
275 jjtree.clearNodeScope(jjtn000);
276 jjtc000 = false;
277 } else {
278 jjtree.popNode();
279 }
280 if (jjte000 instanceof RuntimeException) {
281 {if (true) throw (RuntimeException)jjte000;}
282 }
283 if (jjte000 instanceof ParseException) {
284 {if (true) throw (ParseException)jjte000;}
285 }
286 {if (true) throw (Error)jjte000;}
287 } finally {
288 if (jjtc000) {
289 jjtree.closeNodeScope(jjtn000, true);
290 }
291 }
292 throw new Error("Missing return statement in function");
293 }
294
295 final public ASTDDLCommand DDLCommand() throws ParseException {
296
297 ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298 boolean jjtc000 = true;
299 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300 try {
301 simpleNode = DDLEvent();
302 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303 jjtree.closeNodeScope(jjtn000, true);
304 jjtc000 = false;
305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
306 } catch (Throwable jjte000) {
307 if (jjtc000) {
308 jjtree.clearNodeScope(jjtn000);
309 jjtc000 = false;
310 } else {
311 jjtree.popNode();
312 }
313 if (jjte000 instanceof RuntimeException) {
314 {if (true) throw (RuntimeException)jjte000;}
315 }
316 if (jjte000 instanceof ParseException) {
317 {if (true) throw (ParseException)jjte000;}
318 }
319 {if (true) throw (Error)jjte000;}
320 } finally {
321 if (jjtc000) {
322 jjtree.closeNodeScope(jjtn000, true);
323 }
324 }
325 throw new Error("Missing return statement in function");
326 }
327
328 final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329
330 ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331 boolean jjtc000 = true;
332 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333 try {
334 switch (jj_nt.kind) {
335 case 2:
336 jj_consume_token(2);
337 break;
338 case ACCEPT:
339 jj_consume_token(ACCEPT);
340 break;
341 case COLUMN:
342 jj_consume_token(COLUMN);
343 break;
344 case CONNECT:
345 jj_consume_token(CONNECT);
346 break;
347 case COPY:
348 jj_consume_token(COPY);
349 break;
350 case DEFINE:
351 jj_consume_token(DEFINE);
352 break;
353 case DISCONNECT:
354 jj_consume_token(DISCONNECT);
355 break;
356 case EXECUTE:
357 jj_consume_token(EXECUTE);
358 break;
359 case EXIT:
360 jj_consume_token(EXIT);
361 break;
362 case HOST:
363 jj_consume_token(HOST);
364 break;
365 case PRINT:
366 jj_consume_token(PRINT);
367 break;
368 case PROMPT:
369 jj_consume_token(PROMPT);
370 break;
371 case QUIT:
372 jj_consume_token(QUIT);
373 break;
374 case REMARK:
375 jj_consume_token(REMARK);
376 break;
377 case SET:
378 jj_consume_token(SET);
379 break;
380 case SHOW:
381 jj_consume_token(SHOW);
382 break;
383 case SPOOL:
384 jj_consume_token(SPOOL);
385 break;
386 case START:
387 jj_consume_token(START);
388 break;
389 case UNDEFINE:
390 jj_consume_token(UNDEFINE);
391 break;
392 case VARIABLE:
393 jj_consume_token(VARIABLE);
394 break;
395 case WHENEVER:
396 jj_consume_token(WHENEVER);
397 break;
398 case COMMENT:
399 jj_consume_token(COMMENT);
400 break;
401 case GRANT:
402 jj_consume_token(GRANT);
403 break;
404 case REVOKE:
405 jj_consume_token(REVOKE);
406 break;
407 case DROP:
408 jj_consume_token(DROP);
409 break;
410 case IDENTIFIER:
411 jj_consume_token(IDENTIFIER);
412 break;
413 case 3:
414 jj_consume_token(3);
415 jj_consume_token(ATTACH);
416 break;
417 default:
418 jj_la1[4] = jj_gen;
419 jj_consume_token(-1);
420 throw new ParseException();
421 }
422 sb.append(token.image) ; sb.append(" ...") ;
423 Skip2NextTokenOccurrence(EOL);
424 jjtree.closeNodeScope(jjtn000, true);
425 jjtc000 = false;
426 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
427 } catch (Throwable jjte000) {
428 if (jjtc000) {
429 jjtree.clearNodeScope(jjtn000);
430 jjtc000 = false;
431 } else {
432 jjtree.popNode();
433 }
434 if (jjte000 instanceof RuntimeException) {
435 {if (true) throw (RuntimeException)jjte000;}
436 }
437 if (jjte000 instanceof ParseException) {
438 {if (true) throw (ParseException)jjte000;}
439 }
440 {if (true) throw (Error)jjte000;}
441 } finally {
442 if (jjtc000) {
443 jjtree.closeNodeScope(jjtn000, true);
444 }
445 }
446 throw new Error("Missing return statement in function");
447 }
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474 final public ASTGlobal Global() throws ParseException {
475
476 ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477 boolean jjtc000 = true;
478 jjtree.openNodeScope(jjtn000);
479 try {
480 if (jj_2_14(2147483647)) {
481 label_3:
482 while (true) {
483 switch (jj_nt.kind) {
484 case 21:
485 ;
486 break;
487 default:
488 jj_la1[5] = jj_gen;
489 break label_3;
490 }
491 Label();
492 }
493 Block();
494 jj_consume_token(4);
495 } else if (jj_2_15(4)) {
496 ProgramUnit();
497 } else {
498 jj_consume_token(-1);
499 throw new ParseException();
500 }
501 jjtree.closeNodeScope(jjtn000, true);
502 jjtc000 = false;
503 {if (true) return jjtn000 ;}
504 } catch (Throwable jjte000) {
505 if (jjtc000) {
506 jjtree.clearNodeScope(jjtn000);
507 jjtc000 = false;
508 } else {
509 jjtree.popNode();
510 }
511 if (jjte000 instanceof RuntimeException) {
512 {if (true) throw (RuntimeException)jjte000;}
513 }
514 if (jjte000 instanceof ParseException) {
515 {if (true) throw (ParseException)jjte000;}
516 }
517 {if (true) throw (Error)jjte000;}
518 } finally {
519 if (jjtc000) {
520 jjtree.closeNodeScope(jjtn000, true);
521 }
522 }
523 throw new Error("Missing return statement in function");
524 }
525
526 final public ASTBlock Block() throws ParseException {
527
528 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529 boolean jjtc000 = true;
530 jjtree.openNodeScope(jjtn000);
531 try {
532 switch (jj_nt.kind) {
533 case DECLARE:
534 jj_consume_token(DECLARE);
535 DeclarativeSection();
536 break;
537 default:
538 jj_la1[6] = jj_gen;
539 ;
540 }
541 jj_consume_token(BEGIN);
542 label_4:
543 while (true) {
544 switch (jj_nt.kind) {
545 case 5:
546 case 16:
547 case 17:
548 case 21:
549 case REPLACE:
550 case DEFINER:
551 case CURRENT_USER:
552 case LANGUAGE:
553 case INLINE:
554 case ADD:
555 case AGGREGATE:
556 case ARRAY:
557 case AT:
558 case ATTRIBUTE:
559 case AUTHID:
560 case BEGIN:
561 case BODY:
562 case BULK:
563 case BYTE:
564 case CASCADE:
565 case CASE:
566 case CLOSE:
567 case COALESCE:
568 case COLLECT:
569 case COLUMN:
570 case COMMENT:
571 case COMMIT:
572 case CONSTRUCTOR:
573 case CONTINUE:
574 case CONVERT:
575 case CURRENT:
576 case CURSOR:
577 case DATA:
578 case DATE:
579 case DAY:
580 case DECLARE:
581 case DELETE:
582 case DISABLE:
583 case EDITIONABLE:
584 case ELEMENT:
585 case ENABLE:
586 case ESCAPE:
587 case EXCEPT:
588 case EXCEPTIONS:
589 case EXECUTE:
590 case EXIT:
591 case EXTERNAL:
592 case EXTENDS:
593 case EXTRACT:
594 case FALSE:
595 case FETCH:
596 case FINAL:
597 case FOR:
598 case FORALL:
599 case FORCE:
600 case FUNCTION:
601 case GLOBAL:
602 case GOTO:
603 case HASH:
604 case HEAP:
605 case HOUR:
606 case IF:
607 case IMMEDIATE:
608 case INDICES:
609 case INDEXTYPE:
610 case INDICATOR:
611 case INSERT:
612 case INSTANTIABLE:
613 case INTERVAL:
614 case INVALIDATE:
615 case ISOLATION:
616 case JAVA:
617 case LEVEL:
618 case LIMIT:
619 case LOCK:
620 case LOOP:
621 case MAP:
622 case MAX:
623 case MEMBER:
624 case MERGE:
625 case MIN:
626 case MINUTE:
627 case MLSLABEL:
628 case MODIFY:
629 case MOD:
630 case MONTH:
631 case NATURAL:
632 case NEW:
633 case NEW_DOT:
634 case NO:
635 case NONEDITIONABLE:
636 case NOT:
637 case NULL:
638 case NULLIF:
639 case OBJECT:
640 case OID:
641 case OPAQUE:
642 case OPEN:
643 case OPERATOR:
644 case ORGANIZATION:
645 case OTHERS:
646 case OVERRIDING:
647 case PACKAGE:
648 case PARTITION:
649 case PIPE:
650 case PRAGMA:
651 case PRESERVE:
652 case PRIVATE:
653 case PROCEDURE:
654 case RAISE:
655 case RANGE:
656 case RAW:
657 case REAL:
658 case RECORD:
659 case REF:
660 case RELEASE:
661 case RELIES_ON:
662 case RENAME:
663 case RESULT:
664 case RETURN:
665 case RETURNING:
666 case REVERSE:
667 case ROLLBACK:
668 case ROW:
669 case ROWS:
670 case ROWID:
671 case ROWNUM:
672 case SAVE:
673 case SAVEPOINT:
674 case SECOND:
675 case SELECT:
676 case SELF:
677 case SET:
678 case SPACE:
679 case SQL:
680 case SQLCODE:
681 case SQLERRM:
682 case STATIC:
683 case SUBTYPE:
684 case SUBSTITUTABLE:
685 case SUCCESSFUL:
686 case SYSDATE:
687 case SYS_REFCURSOR:
688 case TEMPORARY:
689 case TIME:
690 case TIMESTAMP:
691 case TIMEZONE_REGION:
692 case TIMEZONE_ABBR:
693 case TIMEZONE_MINUTE:
694 case TIMEZONE_HOUR:
695 case TRANSACTION:
696 case TRUE:
697 case TYPE:
698 case UNDER:
699 case USING:
700 case WHILE:
701 case YES:
702 case SHOW:
703 case A:
704 case UPDATE:
705 case DOUBLE:
706 case DEC:
707 case PRECISION:
708 case INT:
709 case NUMERIC:
710 case NCHAR:
711 case NVARCHAR2:
712 case STRING:
713 case UROWID:
714 case VARRAY:
715 case VARYING:
716 case BFILE:
717 case BLOB:
718 case CLOB:
719 case NCLOB:
720 case YEAR:
721 case LOCAL:
722 case WITH:
723 case ZONE:
724 case CHARACTER:
725 case AFTER:
726 case BEFORE:
727 case OLD:
728 case PARENT:
729 case CC_IF:
730 case CC_ERROR:
731 case ANALYZE:
732 case ASSOCIATE:
733 case AUDIT:
734 case COMPOUND:
735 case DATABASE:
736 case CALL:
737 case DDL:
738 case DISASSOCIATE:
739 case EACH:
740 case FOLLOWS:
741 case LOGOFF:
742 case LOGON:
743 case NESTED:
744 case NOAUDIT:
745 case SCHEMA:
746 case SERVERERROR:
747 case SHUTDOWN:
748 case STARTUP:
749 case STATEMENT:
750 case STATISTICS:
751 case SUSPEND:
752 case TRUNCATE:
753 case WRAPPED:
754 case LIBRARY:
755 case NAME:
756 case STRUCT:
757 case CONTEXT:
758 case PARAMETERS:
759 case LENGTH:
760 case TDO:
761 case MAXLEN:
762 case CHARSETID:
763 case CHARSETFORM:
764 case ACCEPT:
765 case ACCESSIBLE:
766 case COPY:
767 case DEFINE:
768 case DISCONNECT:
769 case HOST:
770 case PRINT:
771 case QUIT:
772 case REMARK:
773 case UNDEFINE:
774 case VARIABLE:
775 case WHENEVER:
776 case ATTACH:
777 case CAST:
778 case TREAT:
779 case TRIM:
780 case LEFT:
781 case RIGHT:
782 case BOTH:
783 case EMPTY:
784 case MULTISET:
785 case SUBMULTISET:
786 case LEADING:
787 case TRAILING:
788 case CHAR_CS:
789 case NCHAR_CS:
790 case DBTIMEZONE:
791 case SESSIONTIMEZONE:
792 case AUTHENTICATED:
793 case LINK:
794 case SHARED:
795 case DIRECTORY:
796 case USER:
797 case IDENTIFIER:
798 case UNSIGNED_NUMERIC_LITERAL:
799 case CHARACTER_LITERAL:
800 case STRING_LITERAL:
801 case QUOTED_LITERAL:
802 ;
803 break;
804 default:
805 jj_la1[7] = jj_gen;
806 break label_4;
807 }
808 Statement();
809 }
810 switch (jj_nt.kind) {
811 case EXCEPTION:
812 ExceptionHandler();
813 break;
814 default:
815 jj_la1[8] = jj_gen;
816 ;
817 }
818 jj_consume_token(END);
819 switch (jj_nt.kind) {
820 case IDENTIFIER:
821 jj_consume_token(IDENTIFIER);
822 break;
823 default:
824 jj_la1[9] = jj_gen;
825 ;
826 }
827 jjtree.closeNodeScope(jjtn000, true);
828 jjtc000 = false;
829 {if (true) return jjtn000 ;}
830 } catch (Throwable jjte000) {
831 if (jjtc000) {
832 jjtree.clearNodeScope(jjtn000);
833 jjtc000 = false;
834 } else {
835 jjtree.popNode();
836 }
837 if (jjte000 instanceof RuntimeException) {
838 {if (true) throw (RuntimeException)jjte000;}
839 }
840 if (jjte000 instanceof ParseException) {
841 {if (true) throw (ParseException)jjte000;}
842 }
843 {if (true) throw (Error)jjte000;}
844 } finally {
845 if (jjtc000) {
846 jjtree.closeNodeScope(jjtn000, true);
847 }
848 }
849 throw new Error("Missing return statement in function");
850 }
851
852 final public ASTPackageSpecification PackageSpecification() throws ParseException {
853
854 ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855 boolean jjtc000 = true;
856 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857 try {
858 switch (jj_nt.kind) {
859 case CREATE:
860 jj_consume_token(CREATE);
861 switch (jj_nt.kind) {
862 case OR:
863 jj_consume_token(OR);
864 jj_consume_token(REPLACE);
865 break;
866 default:
867 jj_la1[10] = jj_gen;
868 ;
869 }
870 switch (jj_nt.kind) {
871 case EDITIONABLE:
872 case NONEDITIONABLE:
873 switch (jj_nt.kind) {
874 case EDITIONABLE:
875 jj_consume_token(EDITIONABLE);
876 break;
877 case NONEDITIONABLE:
878 jj_consume_token(NONEDITIONABLE);
879 break;
880 default:
881 jj_la1[11] = jj_gen;
882 jj_consume_token(-1);
883 throw new ParseException();
884 }
885 break;
886 default:
887 jj_la1[12] = jj_gen;
888 ;
889 }
890 break;
891 default:
892 jj_la1[13] = jj_gen;
893 ;
894 }
895 jj_consume_token(PACKAGE);
896 simpleNode = ObjectNameDeclaration();
897 label_5:
898 while (true) {
899 switch (jj_nt.kind) {
900 case AUTHID:
901 case ACCESSIBLE:
902 ;
903 break;
904 default:
905 jj_la1[14] = jj_gen;
906 break label_5;
907 }
908 switch (jj_nt.kind) {
909 case AUTHID:
910 jj_consume_token(AUTHID);
911 switch (jj_nt.kind) {
912 case CURRENT_USER:
913 jj_consume_token(CURRENT_USER);
914 break;
915 case DEFINER:
916 jj_consume_token(DEFINER);
917 break;
918 default:
919 jj_la1[15] = jj_gen;
920 jj_consume_token(-1);
921 throw new ParseException();
922 }
923 break;
924 case ACCESSIBLE:
925 AccessibleByClause();
926 break;
927 default:
928 jj_la1[16] = jj_gen;
929 jj_consume_token(-1);
930 throw new ParseException();
931 }
932 }
933 switch (jj_nt.kind) {
934 case WRAPPED:
935 WrappedObject();
936 break;
937 case AS:
938 case IS:
939 switch (jj_nt.kind) {
940 case IS:
941 jj_consume_token(IS);
942 break;
943 case AS:
944 jj_consume_token(AS);
945 break;
946 default:
947 jj_la1[17] = jj_gen;
948 jj_consume_token(-1);
949 throw new ParseException();
950 }
951 DeclarativeSection();
952 jj_consume_token(END);
953 switch (jj_nt.kind) {
954 case REPLACE:
955 case DEFINER:
956 case CURRENT_USER:
957 case SERIALLY_REUSABLE:
958 case RESTRICT_REFERENCES:
959 case EXCEPTION_INIT:
960 case AUTONOMOUS_TRANSACTION:
961 case LANGUAGE:
962 case INLINE:
963 case ADD:
964 case AGGREGATE:
965 case ALL:
966 case ALTER:
967 case AND:
968 case ANY:
969 case ARRAY:
970 case AS:
971 case ASC:
972 case AT:
973 case ATTRIBUTE:
974 case AUTHID:
975 case AVG:
976 case BETWEEN:
977 case BINARY_INTEGER:
978 case BODY:
979 case BOOLEAN:
980 case BULK:
981 case BY:
982 case BYTE:
983 case CASCADE:
984 case CASE:
985 case CHAR:
986 case CHAR_BASE:
987 case CHECK:
988 case CLOSE:
989 case CLUSTER:
990 case COALESCE:
991 case COLLECT:
992 case COLUMN:
993 case COMMENT:
994 case COMMIT:
995 case COMPRESS:
996 case CONNECT:
997 case CONSTANT:
998 case CONSTRUCTOR:
999 case CONTINUE:
1000 case CONVERT:
1001 case CREATE:
1002 case CURRENT:
1003 case CURRVAL:
1004 case CURSOR:
1005 case DATA:
1006 case DATE:
1007 case DAY:
1008 case DECLARE:
1009 case DECIMAL:
1010 case _DEFAULT:
1011 case DELETE:
1012 case DESC:
1013 case DISABLE:
1014 case DISTINCT:
1015 case DO:
1016 case DROP:
1017 case EDITIONABLE:
1018 case ELEMENT:
1019 case ELSE:
1020 case ELSIF:
1021 case ENABLE:
1022 case ESCAPE:
1023 case EXCEPT:
1024 case EXCEPTION:
1025 case EXCEPTIONS:
1026 case EXCLUSIVE:
1027 case EXECUTE:
1028 case EXISTS:
1029 case EXIT:
1030 case EXTERNAL:
1031 case EXTENDS:
1032 case EXTRACT:
1033 case FALSE:
1034 case FETCH:
1035 case FINAL:
1036 case FLOAT:
1037 case FOR:
1038 case FORALL:
1039 case FORCE:
1040 case FROM:
1041 case FUNCTION:
1042 case GLOBAL:
1043 case GOTO:
1044 case GROUP:
1045 case HASH:
1046 case HAVING:
1047 case HEAP:
1048 case HOUR:
1049 case IF:
1050 case IMMEDIATE:
1051 case IN:
1052 case INDEX:
1053 case INDICES:
1054 case INDEXTYPE:
1055 case INDICATOR:
1056 case INSERT:
1057 case INSTANTIABLE:
1058 case INTEGER:
1059 case INTERFACE:
1060 case INTERSECT:
1061 case INTERVAL:
1062 case INTO:
1063 case INVALIDATE:
1064 case IS:
1065 case ISOLATION:
1066 case JAVA:
1067 case LEVEL:
1068 case LIKE:
1069 case LIMIT:
1070 case LIMITED:
1071 case LOCK:
1072 case LONG:
1073 case LOOP:
1074 case MAP:
1075 case MAX:
1076 case MEMBER:
1077 case MERGE:
1078 case MIN:
1079 case MINUS:
1080 case MINUTE:
1081 case MLSLABEL:
1082 case MODIFY:
1083 case MOD:
1084 case MODE:
1085 case MONTH:
1086 case NATURAL:
1087 case NATURALN:
1088 case NEW:
1089 case NEXTVAL:
1090 case NO:
1091 case NOCOPY:
1092 case NONEDITIONABLE:
1093 case NOT:
1094 case NOWAIT:
1095 case NULL:
1096 case NULLIF:
1097 case NUMBER:
1098 case BFILE_BASE:
1099 case BLOB_BASE:
1100 case CLOB_BASE:
1101 case DATE_BASE:
1102 case NUMBER_BASE:
1103 case OBJECT:
1104 case OCIROWID:
1105 case OF:
1106 case OID:
1107 case ON:
1108 case OPAQUE:
1109 case OPEN:
1110 case OPERATOR:
1111 case OPTION:
1112 case OR:
1113 case ORDER:
1114 case ORGANIZATION:
1115 case OTHERS:
1116 case OUT:
1117 case OVERRIDING:
1118 case PACKAGE:
1119 case PARTITION:
1120 case PCTFREE:
1121 case PLS_INTEGER:
1122 case POSITIVE:
1123 case POSITIVEN:
1124 case PRESERVE:
1125 case PRIOR:
1126 case PROMPT:
1127 case PRIVATE:
1128 case PROCEDURE:
1129 case PUBLIC:
1130 case RAISE:
1131 case RANGE:
1132 case RAW:
1133 case REAL:
1134 case RECORD:
1135 case REF:
1136 case RELEASE:
1137 case RELIES_ON:
1138 case RENAME:
1139 case RESULT:
1140 case RETURN:
1141 case RETURNING:
1142 case REVERSE:
1143 case ROLLBACK:
1144 case ROW:
1145 case ROWS:
1146 case ROWID:
1147 case ROWNUM:
1148 case ROWTYPE:
1149 case SAVE:
1150 case SAVEPOINT:
1151 case SECOND:
1152 case SELECT:
1153 case SELF:
1154 case SEPARATE:
1155 case SET:
1156 case SHARE:
1157 case SMALLINT:
1158 case SPACE:
1159 case SQL:
1160 case SQLCODE:
1161 case SQLERRM:
1162 case START:
1163 case STATIC:
1164 case STDDEV:
1165 case SUBTYPE:
1166 case SUBSTITUTABLE:
1167 case SUCCESSFUL:
1168 case SUM:
1169 case SYNONYM:
1170 case SYSDATE:
1171 case SYS_REFCURSOR:
1172 case TABLE:
1173 case TEMPORARY:
1174 case THEN:
1175 case TIME:
1176 case TIMESTAMP:
1177 case TIMEZONE_REGION:
1178 case TIMEZONE_ABBR:
1179 case TIMEZONE_MINUTE:
1180 case TIMEZONE_HOUR:
1181 case TO:
1182 case TRANSACTION:
1183 case TRIGGER:
1184 case TRUE:
1185 case TYPE:
1186 case UI:
1187 case UNDER:
1188 case USING:
1189 case WHILE:
1190 case YES:
1191 case SHOW:
1192 case A:
1193 case UPDATE:
1194 case VARCHAR:
1195 case VARCHAR2:
1196 case DOUBLE:
1197 case DEC:
1198 case PRECISION:
1199 case INT:
1200 case NUMERIC:
1201 case SIGNTYPE:
1202 case NCHAR:
1203 case NVARCHAR2:
1204 case STRING:
1205 case UROWID:
1206 case VARRAY:
1207 case VARYING:
1208 case BFILE:
1209 case BLOB:
1210 case CLOB:
1211 case NCLOB:
1212 case YEAR:
1213 case LOCAL:
1214 case WITH:
1215 case ZONE:
1216 case CHARACTER:
1217 case AFTER:
1218 case BEFORE:
1219 case OLD:
1220 case PARENT:
1221 case ANALYZE:
1222 case ASSOCIATE:
1223 case AUDIT:
1224 case COMPOUND:
1225 case DATABASE:
1226 case CALL:
1227 case DDL:
1228 case DISASSOCIATE:
1229 case EACH:
1230 case FOLLOWS:
1231 case LOGOFF:
1232 case LOGON:
1233 case NESTED:
1234 case NOAUDIT:
1235 case SCHEMA:
1236 case SERVERERROR:
1237 case SHUTDOWN:
1238 case STARTUP:
1239 case STATEMENT:
1240 case STATISTICS:
1241 case SUSPEND:
1242 case TRUNCATE:
1243 case WRAPPED:
1244 case LIBRARY:
1245 case NAME:
1246 case STRUCT:
1247 case CONTEXT:
1248 case PARAMETERS:
1249 case LENGTH:
1250 case TDO:
1251 case MAXLEN:
1252 case CHARSETID:
1253 case CHARSETFORM:
1254 case ACCEPT:
1255 case ACCESSIBLE:
1256 case COPY:
1257 case DEFINE:
1258 case DISCONNECT:
1259 case HOST:
1260 case PRINT:
1261 case QUIT:
1262 case REMARK:
1263 case UNDEFINE:
1264 case VARIABLE:
1265 case WHENEVER:
1266 case ATTACH:
1267 case CAST:
1268 case TREAT:
1269 case TRIM:
1270 case LEFT:
1271 case RIGHT:
1272 case BOTH:
1273 case EMPTY:
1274 case MULTISET:
1275 case SUBMULTISET:
1276 case LEADING:
1277 case TRAILING:
1278 case CHAR_CS:
1279 case NCHAR_CS:
1280 case DBTIMEZONE:
1281 case SESSIONTIMEZONE:
1282 case AUTHENTICATED:
1283 case LINK:
1284 case SHARED:
1285 case DIRECTORY:
1286 case USER:
1287 case IDENTIFIER:
1288 case QUOTED_LITERAL:
1289 case SQLDATA_CLASS:
1290 case CUSTOMDATUM_CLASS:
1291 case ORADATA_CLASS:
1292 case JAVA_INTERFACE_CLASS:
1293 ID();
1294 break;
1295 default:
1296 jj_la1[18] = jj_gen;
1297 ;
1298 }
1299 jj_consume_token(4);
1300 break;
1301 default:
1302 jj_la1[19] = jj_gen;
1303 jj_consume_token(-1);
1304 throw new ParseException();
1305 }
1306 jjtree.closeNodeScope(jjtn000, true);
1307 jjtc000 = false;
1308 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
1309 } catch (Throwable jjte000) {
1310 if (jjtc000) {
1311 jjtree.clearNodeScope(jjtn000);
1312 jjtc000 = false;
1313 } else {
1314 jjtree.popNode();
1315 }
1316 if (jjte000 instanceof RuntimeException) {
1317 {if (true) throw (RuntimeException)jjte000;}
1318 }
1319 if (jjte000 instanceof ParseException) {
1320 {if (true) throw (ParseException)jjte000;}
1321 }
1322 {if (true) throw (Error)jjte000;}
1323 } finally {
1324 if (jjtc000) {
1325 jjtree.closeNodeScope(jjtn000, true);
1326 }
1327 }
1328 throw new Error("Missing return statement in function");
1329 }
1330
1331 final public ASTPackageBody PackageBody() throws ParseException {
1332
1333 ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334 boolean jjtc000 = true;
1335 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336 try {
1337 switch (jj_nt.kind) {
1338 case CREATE:
1339 jj_consume_token(CREATE);
1340 switch (jj_nt.kind) {
1341 case OR:
1342 jj_consume_token(OR);
1343 jj_consume_token(REPLACE);
1344 break;
1345 default:
1346 jj_la1[20] = jj_gen;
1347 ;
1348 }
1349 switch (jj_nt.kind) {
1350 case EDITIONABLE:
1351 case NONEDITIONABLE:
1352 switch (jj_nt.kind) {
1353 case EDITIONABLE:
1354 jj_consume_token(EDITIONABLE);
1355 break;
1356 case NONEDITIONABLE:
1357 jj_consume_token(NONEDITIONABLE);
1358 break;
1359 default:
1360 jj_la1[21] = jj_gen;
1361 jj_consume_token(-1);
1362 throw new ParseException();
1363 }
1364 break;
1365 default:
1366 jj_la1[22] = jj_gen;
1367 ;
1368 }
1369 break;
1370 default:
1371 jj_la1[23] = jj_gen;
1372 ;
1373 }
1374 switch (jj_nt.kind) {
1375 case PACKAGE:
1376 jj_consume_token(PACKAGE);
1377 break;
1378 case TYPE:
1379 jj_consume_token(TYPE);
1380 break;
1381 default:
1382 jj_la1[24] = jj_gen;
1383 jj_consume_token(-1);
1384 throw new ParseException();
1385 }
1386 jj_consume_token(BODY);
1387 simpleNode = ObjectNameDeclaration();
1388 switch (jj_nt.kind) {
1389 case WRAPPED:
1390 WrappedObject();
1391 break;
1392 case AS:
1393 case IS:
1394 switch (jj_nt.kind) {
1395 case IS:
1396 jj_consume_token(IS);
1397 break;
1398 case AS:
1399 jj_consume_token(AS);
1400 break;
1401 default:
1402 jj_la1[25] = jj_gen;
1403 jj_consume_token(-1);
1404 throw new ParseException();
1405 }
1406 DeclarativeSection();
1407 switch (jj_nt.kind) {
1408 case BEGIN:
1409 jj_consume_token(BEGIN);
1410 label_6:
1411 while (true) {
1412 switch (jj_nt.kind) {
1413 case 5:
1414 case 16:
1415 case 17:
1416 case 21:
1417 case REPLACE:
1418 case DEFINER:
1419 case CURRENT_USER:
1420 case LANGUAGE:
1421 case INLINE:
1422 case ADD:
1423 case AGGREGATE:
1424 case ARRAY:
1425 case AT:
1426 case ATTRIBUTE:
1427 case AUTHID:
1428 case BEGIN:
1429 case BODY:
1430 case BULK:
1431 case BYTE:
1432 case CASCADE:
1433 case CASE:
1434 case CLOSE:
1435 case COALESCE:
1436 case COLLECT:
1437 case COLUMN:
1438 case COMMENT:
1439 case COMMIT:
1440 case CONSTRUCTOR:
1441 case CONTINUE:
1442 case CONVERT:
1443 case CURRENT:
1444 case CURSOR:
1445 case DATA:
1446 case DATE:
1447 case DAY:
1448 case DECLARE:
1449 case DELETE:
1450 case DISABLE:
1451 case EDITIONABLE:
1452 case ELEMENT:
1453 case ENABLE:
1454 case ESCAPE:
1455 case EXCEPT:
1456 case EXCEPTIONS:
1457 case EXECUTE:
1458 case EXIT:
1459 case EXTERNAL:
1460 case EXTENDS:
1461 case EXTRACT:
1462 case FALSE:
1463 case FETCH:
1464 case FINAL:
1465 case FOR:
1466 case FORALL:
1467 case FORCE:
1468 case FUNCTION:
1469 case GLOBAL:
1470 case GOTO:
1471 case HASH:
1472 case HEAP:
1473 case HOUR:
1474 case IF:
1475 case IMMEDIATE:
1476 case INDICES:
1477 case INDEXTYPE:
1478 case INDICATOR:
1479 case INSERT:
1480 case INSTANTIABLE:
1481 case INTERVAL:
1482 case INVALIDATE:
1483 case ISOLATION:
1484 case JAVA:
1485 case LEVEL:
1486 case LIMIT:
1487 case LOCK:
1488 case LOOP:
1489 case MAP:
1490 case MAX:
1491 case MEMBER:
1492 case MERGE:
1493 case MIN:
1494 case MINUTE:
1495 case MLSLABEL:
1496 case MODIFY:
1497 case MOD:
1498 case MONTH:
1499 case NATURAL:
1500 case NEW:
1501 case NEW_DOT:
1502 case NO:
1503 case NONEDITIONABLE:
1504 case NOT:
1505 case NULL:
1506 case NULLIF:
1507 case OBJECT:
1508 case OID:
1509 case OPAQUE:
1510 case OPEN:
1511 case OPERATOR:
1512 case ORGANIZATION:
1513 case OTHERS:
1514 case OVERRIDING:
1515 case PACKAGE:
1516 case PARTITION:
1517 case PIPE:
1518 case PRAGMA:
1519 case PRESERVE:
1520 case PRIVATE:
1521 case PROCEDURE:
1522 case RAISE:
1523 case RANGE:
1524 case RAW:
1525 case REAL:
1526 case RECORD:
1527 case REF:
1528 case RELEASE:
1529 case RELIES_ON:
1530 case RENAME:
1531 case RESULT:
1532 case RETURN:
1533 case RETURNING:
1534 case REVERSE:
1535 case ROLLBACK:
1536 case ROW:
1537 case ROWS:
1538 case ROWID:
1539 case ROWNUM:
1540 case SAVE:
1541 case SAVEPOINT:
1542 case SECOND:
1543 case SELECT:
1544 case SELF:
1545 case SET:
1546 case SPACE:
1547 case SQL:
1548 case SQLCODE:
1549 case SQLERRM:
1550 case STATIC:
1551 case SUBTYPE:
1552 case SUBSTITUTABLE:
1553 case SUCCESSFUL:
1554 case SYSDATE:
1555 case SYS_REFCURSOR:
1556 case TEMPORARY:
1557 case TIME:
1558 case TIMESTAMP:
1559 case TIMEZONE_REGION:
1560 case TIMEZONE_ABBR:
1561 case TIMEZONE_MINUTE:
1562 case TIMEZONE_HOUR:
1563 case TRANSACTION:
1564 case TRUE:
1565 case TYPE:
1566 case UNDER:
1567 case USING:
1568 case WHILE:
1569 case YES:
1570 case SHOW:
1571 case A:
1572 case UPDATE:
1573 case DOUBLE:
1574 case DEC:
1575 case PRECISION:
1576 case INT:
1577 case NUMERIC:
1578 case NCHAR:
1579 case NVARCHAR2:
1580 case STRING:
1581 case UROWID:
1582 case VARRAY:
1583 case VARYING:
1584 case BFILE:
1585 case BLOB:
1586 case CLOB:
1587 case NCLOB:
1588 case YEAR:
1589 case LOCAL:
1590 case WITH:
1591 case ZONE:
1592 case CHARACTER:
1593 case AFTER:
1594 case BEFORE:
1595 case OLD:
1596 case PARENT:
1597 case CC_IF:
1598 case CC_ERROR:
1599 case ANALYZE:
1600 case ASSOCIATE:
1601 case AUDIT:
1602 case COMPOUND:
1603 case DATABASE:
1604 case CALL:
1605 case DDL:
1606 case DISASSOCIATE:
1607 case EACH:
1608 case FOLLOWS:
1609 case LOGOFF:
1610 case LOGON:
1611 case NESTED:
1612 case NOAUDIT:
1613 case SCHEMA:
1614 case SERVERERROR:
1615 case SHUTDOWN:
1616 case STARTUP:
1617 case STATEMENT:
1618 case STATISTICS:
1619 case SUSPEND:
1620 case TRUNCATE:
1621 case WRAPPED:
1622 case LIBRARY:
1623 case NAME:
1624 case STRUCT:
1625 case CONTEXT:
1626 case PARAMETERS:
1627 case LENGTH:
1628 case TDO:
1629 case MAXLEN:
1630 case CHARSETID:
1631 case CHARSETFORM:
1632 case ACCEPT:
1633 case ACCESSIBLE:
1634 case COPY:
1635 case DEFINE:
1636 case DISCONNECT:
1637 case HOST:
1638 case PRINT:
1639 case QUIT:
1640 case REMARK:
1641 case UNDEFINE:
1642 case VARIABLE:
1643 case WHENEVER:
1644 case ATTACH:
1645 case CAST:
1646 case TREAT:
1647 case TRIM:
1648 case LEFT:
1649 case RIGHT:
1650 case BOTH:
1651 case EMPTY:
1652 case MULTISET:
1653 case SUBMULTISET:
1654 case LEADING:
1655 case TRAILING:
1656 case CHAR_CS:
1657 case NCHAR_CS:
1658 case DBTIMEZONE:
1659 case SESSIONTIMEZONE:
1660 case AUTHENTICATED:
1661 case LINK:
1662 case SHARED:
1663 case DIRECTORY:
1664 case USER:
1665 case IDENTIFIER:
1666 case UNSIGNED_NUMERIC_LITERAL:
1667 case CHARACTER_LITERAL:
1668 case STRING_LITERAL:
1669 case QUOTED_LITERAL:
1670 ;
1671 break;
1672 default:
1673 jj_la1[26] = jj_gen;
1674 break label_6;
1675 }
1676 Statement();
1677 }
1678 switch (jj_nt.kind) {
1679 case EXCEPTION:
1680 ExceptionHandler();
1681 break;
1682 default:
1683 jj_la1[27] = jj_gen;
1684 ;
1685 }
1686 break;
1687 default:
1688 jj_la1[28] = jj_gen;
1689 ;
1690 }
1691 jj_consume_token(END);
1692 switch (jj_nt.kind) {
1693 case REPLACE:
1694 case DEFINER:
1695 case CURRENT_USER:
1696 case SERIALLY_REUSABLE:
1697 case RESTRICT_REFERENCES:
1698 case EXCEPTION_INIT:
1699 case AUTONOMOUS_TRANSACTION:
1700 case LANGUAGE:
1701 case INLINE:
1702 case ADD:
1703 case AGGREGATE:
1704 case ALL:
1705 case ALTER:
1706 case AND:
1707 case ANY:
1708 case ARRAY:
1709 case AS:
1710 case ASC:
1711 case AT:
1712 case ATTRIBUTE:
1713 case AUTHID:
1714 case AVG:
1715 case BETWEEN:
1716 case BINARY_INTEGER:
1717 case BODY:
1718 case BOOLEAN:
1719 case BULK:
1720 case BY:
1721 case BYTE:
1722 case CASCADE:
1723 case CASE:
1724 case CHAR:
1725 case CHAR_BASE:
1726 case CHECK:
1727 case CLOSE:
1728 case CLUSTER:
1729 case COALESCE:
1730 case COLLECT:
1731 case COLUMN:
1732 case COMMENT:
1733 case COMMIT:
1734 case COMPRESS:
1735 case CONNECT:
1736 case CONSTANT:
1737 case CONSTRUCTOR:
1738 case CONTINUE:
1739 case CONVERT:
1740 case CREATE:
1741 case CURRENT:
1742 case CURRVAL:
1743 case CURSOR:
1744 case DATA:
1745 case DATE:
1746 case DAY:
1747 case DECLARE:
1748 case DECIMAL:
1749 case _DEFAULT:
1750 case DELETE:
1751 case DESC:
1752 case DISABLE:
1753 case DISTINCT:
1754 case DO:
1755 case DROP:
1756 case EDITIONABLE:
1757 case ELEMENT:
1758 case ELSE:
1759 case ELSIF:
1760 case ENABLE:
1761 case ESCAPE:
1762 case EXCEPT:
1763 case EXCEPTION:
1764 case EXCEPTIONS:
1765 case EXCLUSIVE:
1766 case EXECUTE:
1767 case EXISTS:
1768 case EXIT:
1769 case EXTERNAL:
1770 case EXTENDS:
1771 case EXTRACT:
1772 case FALSE:
1773 case FETCH:
1774 case FINAL:
1775 case FLOAT:
1776 case FOR:
1777 case FORALL:
1778 case FORCE:
1779 case FROM:
1780 case FUNCTION:
1781 case GLOBAL:
1782 case GOTO:
1783 case GROUP:
1784 case HASH:
1785 case HAVING:
1786 case HEAP:
1787 case HOUR:
1788 case IF:
1789 case IMMEDIATE:
1790 case IN:
1791 case INDEX:
1792 case INDICES:
1793 case INDEXTYPE:
1794 case INDICATOR:
1795 case INSERT:
1796 case INSTANTIABLE:
1797 case INTEGER:
1798 case INTERFACE:
1799 case INTERSECT:
1800 case INTERVAL:
1801 case INTO:
1802 case INVALIDATE:
1803 case IS:
1804 case ISOLATION:
1805 case JAVA:
1806 case LEVEL:
1807 case LIKE:
1808 case LIMIT:
1809 case LIMITED:
1810 case LOCK:
1811 case LONG:
1812 case LOOP:
1813 case MAP:
1814 case MAX:
1815 case MEMBER:
1816 case MERGE:
1817 case MIN:
1818 case MINUS:
1819 case MINUTE:
1820 case MLSLABEL:
1821 case MODIFY:
1822 case MOD:
1823 case MODE:
1824 case MONTH:
1825 case NATURAL:
1826 case NATURALN:
1827 case NEW:
1828 case NEXTVAL:
1829 case NO:
1830 case NOCOPY:
1831 case NONEDITIONABLE:
1832 case NOT:
1833 case NOWAIT:
1834 case NULL:
1835 case NULLIF:
1836 case NUMBER:
1837 case BFILE_BASE:
1838 case BLOB_BASE:
1839 case CLOB_BASE:
1840 case DATE_BASE:
1841 case NUMBER_BASE:
1842 case OBJECT:
1843 case OCIROWID:
1844 case OF:
1845 case OID:
1846 case ON:
1847 case OPAQUE:
1848 case OPEN:
1849 case OPERATOR:
1850 case OPTION:
1851 case OR:
1852 case ORDER:
1853 case ORGANIZATION:
1854 case OTHERS:
1855 case OUT:
1856 case OVERRIDING:
1857 case PACKAGE:
1858 case PARTITION:
1859 case PCTFREE:
1860 case PLS_INTEGER:
1861 case POSITIVE:
1862 case POSITIVEN:
1863 case PRESERVE:
1864 case PRIOR:
1865 case PROMPT:
1866 case PRIVATE:
1867 case PROCEDURE:
1868 case PUBLIC:
1869 case RAISE:
1870 case RANGE:
1871 case RAW:
1872 case REAL:
1873 case RECORD:
1874 case REF:
1875 case RELEASE:
1876 case RELIES_ON:
1877 case RENAME:
1878 case RESULT:
1879 case RETURN:
1880 case RETURNING:
1881 case REVERSE:
1882 case ROLLBACK:
1883 case ROW:
1884 case ROWS:
1885 case ROWID:
1886 case ROWNUM:
1887 case ROWTYPE:
1888 case SAVE:
1889 case SAVEPOINT:
1890 case SECOND:
1891 case SELECT:
1892 case SELF:
1893 case SEPARATE:
1894 case SET:
1895 case SHARE:
1896 case SMALLINT:
1897 case SPACE:
1898 case SQL:
1899 case SQLCODE:
1900 case SQLERRM:
1901 case START:
1902 case STATIC:
1903 case STDDEV:
1904 case SUBTYPE:
1905 case SUBSTITUTABLE:
1906 case SUCCESSFUL:
1907 case SUM:
1908 case SYNONYM:
1909 case SYSDATE:
1910 case SYS_REFCURSOR:
1911 case TABLE:
1912 case TEMPORARY:
1913 case THEN:
1914 case TIME:
1915 case TIMESTAMP:
1916 case TIMEZONE_REGION:
1917 case TIMEZONE_ABBR:
1918 case TIMEZONE_MINUTE:
1919 case TIMEZONE_HOUR:
1920 case TO:
1921 case TRANSACTION:
1922 case TRIGGER:
1923 case TRUE:
1924 case TYPE:
1925 case UI:
1926 case UNDER:
1927 case USING:
1928 case WHILE:
1929 case YES:
1930 case SHOW:
1931 case A:
1932 case UPDATE:
1933 case VARCHAR:
1934 case VARCHAR2:
1935 case DOUBLE:
1936 case DEC:
1937 case PRECISION:
1938 case INT:
1939 case NUMERIC:
1940 case SIGNTYPE:
1941 case NCHAR:
1942 case NVARCHAR2:
1943 case STRING:
1944 case UROWID:
1945 case VARRAY:
1946 case VARYING:
1947 case BFILE:
1948 case BLOB:
1949 case CLOB:
1950 case NCLOB:
1951 case YEAR:
1952 case LOCAL:
1953 case WITH:
1954 case ZONE:
1955 case CHARACTER:
1956 case AFTER:
1957 case BEFORE:
1958 case OLD:
1959 case PARENT:
1960 case ANALYZE:
1961 case ASSOCIATE:
1962 case AUDIT:
1963 case COMPOUND:
1964 case DATABASE:
1965 case CALL:
1966 case DDL:
1967 case DISASSOCIATE:
1968 case EACH:
1969 case FOLLOWS:
1970 case LOGOFF:
1971 case LOGON:
1972 case NESTED:
1973 case NOAUDIT:
1974 case SCHEMA:
1975 case SERVERERROR:
1976 case SHUTDOWN:
1977 case STARTUP:
1978 case STATEMENT:
1979 case STATISTICS:
1980 case SUSPEND:
1981 case TRUNCATE:
1982 case WRAPPED:
1983 case LIBRARY:
1984 case NAME:
1985 case STRUCT:
1986 case CONTEXT:
1987 case PARAMETERS:
1988 case LENGTH:
1989 case TDO:
1990 case MAXLEN:
1991 case CHARSETID:
1992 case CHARSETFORM:
1993 case ACCEPT:
1994 case ACCESSIBLE:
1995 case COPY:
1996 case DEFINE:
1997 case DISCONNECT:
1998 case HOST:
1999 case PRINT:
2000 case QUIT:
2001 case REMARK:
2002 case UNDEFINE:
2003 case VARIABLE:
2004 case WHENEVER:
2005 case ATTACH:
2006 case CAST:
2007 case TREAT:
2008 case TRIM:
2009 case LEFT:
2010 case RIGHT:
2011 case BOTH:
2012 case EMPTY:
2013 case MULTISET:
2014 case SUBMULTISET:
2015 case LEADING:
2016 case TRAILING:
2017 case CHAR_CS:
2018 case NCHAR_CS:
2019 case DBTIMEZONE:
2020 case SESSIONTIMEZONE:
2021 case AUTHENTICATED:
2022 case LINK:
2023 case SHARED:
2024 case DIRECTORY:
2025 case USER:
2026 case IDENTIFIER:
2027 case QUOTED_LITERAL:
2028 case SQLDATA_CLASS:
2029 case CUSTOMDATUM_CLASS:
2030 case ORADATA_CLASS:
2031 case JAVA_INTERFACE_CLASS:
2032 ID();
2033 break;
2034 default:
2035 jj_la1[29] = jj_gen;
2036 ;
2037 }
2038 jj_consume_token(4);
2039 break;
2040 default:
2041 jj_la1[30] = jj_gen;
2042 jj_consume_token(-1);
2043 throw new ParseException();
2044 }
2045 jjtree.closeNodeScope(jjtn000, true);
2046 jjtc000 = false;
2047 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
2048 } catch (Throwable jjte000) {
2049 if (jjtc000) {
2050 jjtree.clearNodeScope(jjtn000);
2051 jjtc000 = false;
2052 } else {
2053 jjtree.popNode();
2054 }
2055 if (jjte000 instanceof RuntimeException) {
2056 {if (true) throw (RuntimeException)jjte000;}
2057 }
2058 if (jjte000 instanceof ParseException) {
2059 {if (true) throw (ParseException)jjte000;}
2060 }
2061 {if (true) throw (Error)jjte000;}
2062 } finally {
2063 if (jjtc000) {
2064 jjtree.closeNodeScope(jjtn000, true);
2065 }
2066 }
2067 throw new Error("Missing return statement in function");
2068 }
2069
2070 final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071
2072 ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073 boolean jjtc000 = true;
2074 jjtree.openNodeScope(jjtn000);
2075 try {
2076 switch (jj_nt.kind) {
2077 case PRAGMA:
2078 Pragma();
2079 break;
2080 default:
2081 jj_la1[31] = jj_gen;
2082 if (jj_2_16(2)) {
2083 ExceptionDeclaration();
2084 } else if (jj_2_17(2147483647)) {
2085 SubTypeDefinition();
2086 } else if (jj_2_18(2147483647)) {
2087 ProgramUnit();
2088 } else if (jj_2_19(4)) {
2089 VariableOrConstantDeclaration();
2090 } else if (jj_2_20(2)) {
2091 CursorSpecification();
2092 } else {
2093 switch (jj_nt.kind) {
2094 case CURSOR:
2095 CursorBody();
2096 break;
2097 case IDENTIFIER:
2098 CollectionDeclaration();
2099 break;
2100 case CONSTRUCTOR:
2101 case CREATE:
2102 case FINAL:
2103 case FUNCTION:
2104 case INSTANTIABLE:
2105 case MAP:
2106 case MEMBER:
2107 case NOT:
2108 case ORDER:
2109 case OVERRIDING:
2110 case PROCEDURE:
2111 case STATIC:
2112 MethodDeclaration();
2113 break;
2114 case CC_IF:
2115 CompilationDeclarationFragment();
2116 break;
2117 default:
2118 jj_la1[32] = jj_gen;
2119 jj_consume_token(-1);
2120 throw new ParseException();
2121 }
2122 }
2123 }
2124 jjtree.closeNodeScope(jjtn000, true);
2125 jjtc000 = false;
2126 {if (true) return jjtn000 ;}
2127 } catch (Throwable jjte000) {
2128 if (jjtc000) {
2129 jjtree.clearNodeScope(jjtn000);
2130 jjtc000 = false;
2131 } else {
2132 jjtree.popNode();
2133 }
2134 if (jjte000 instanceof RuntimeException) {
2135 {if (true) throw (RuntimeException)jjte000;}
2136 }
2137 if (jjte000 instanceof ParseException) {
2138 {if (true) throw (ParseException)jjte000;}
2139 }
2140 {if (true) throw (Error)jjte000;}
2141 } finally {
2142 if (jjtc000) {
2143 jjtree.closeNodeScope(jjtn000, true);
2144 }
2145 }
2146 throw new Error("Missing return statement in function");
2147 }
2148
2149 final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150
2151 ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152 boolean jjtc000 = true;
2153 jjtree.openNodeScope(jjtn000);
2154 try {
2155 label_7:
2156 while (true) {
2157 switch (jj_nt.kind) {
2158 case REPLACE:
2159 case DEFINER:
2160 case CURRENT_USER:
2161 case SERIALLY_REUSABLE:
2162 case RESTRICT_REFERENCES:
2163 case EXCEPTION_INIT:
2164 case AUTONOMOUS_TRANSACTION:
2165 case LANGUAGE:
2166 case INLINE:
2167 case ADD:
2168 case AGGREGATE:
2169 case ALL:
2170 case ALTER:
2171 case AND:
2172 case ANY:
2173 case ARRAY:
2174 case AS:
2175 case ASC:
2176 case AT:
2177 case ATTRIBUTE:
2178 case AUTHID:
2179 case AVG:
2180 case BETWEEN:
2181 case BINARY_INTEGER:
2182 case BODY:
2183 case BOOLEAN:
2184 case BULK:
2185 case BY:
2186 case BYTE:
2187 case CASCADE:
2188 case CASE:
2189 case CHAR:
2190 case CHAR_BASE:
2191 case CHECK:
2192 case CLOSE:
2193 case CLUSTER:
2194 case COALESCE:
2195 case COLLECT:
2196 case COLUMN:
2197 case COMMENT:
2198 case COMMIT:
2199 case COMPRESS:
2200 case CONNECT:
2201 case CONSTANT:
2202 case CONSTRUCTOR:
2203 case CONTINUE:
2204 case CONVERT:
2205 case CREATE:
2206 case CURRENT:
2207 case CURRVAL:
2208 case CURSOR:
2209 case DATA:
2210 case DATE:
2211 case DAY:
2212 case DECLARE:
2213 case DECIMAL:
2214 case _DEFAULT:
2215 case DELETE:
2216 case DESC:
2217 case DISABLE:
2218 case DISTINCT:
2219 case DO:
2220 case DROP:
2221 case EDITIONABLE:
2222 case ELEMENT:
2223 case ELSE:
2224 case ELSIF:
2225 case ENABLE:
2226 case ESCAPE:
2227 case EXCEPT:
2228 case EXCEPTION:
2229 case EXCEPTIONS:
2230 case EXCLUSIVE:
2231 case EXECUTE:
2232 case EXISTS:
2233 case EXIT:
2234 case EXTERNAL:
2235 case EXTENDS:
2236 case EXTRACT:
2237 case FALSE:
2238 case FETCH:
2239 case FINAL:
2240 case FLOAT:
2241 case FOR:
2242 case FORALL:
2243 case FORCE:
2244 case FROM:
2245 case FUNCTION:
2246 case GLOBAL:
2247 case GOTO:
2248 case GROUP:
2249 case HASH:
2250 case HAVING:
2251 case HEAP:
2252 case HOUR:
2253 case IF:
2254 case IMMEDIATE:
2255 case IN:
2256 case INDEX:
2257 case INDICES:
2258 case INDEXTYPE:
2259 case INDICATOR:
2260 case INSERT:
2261 case INSTANTIABLE:
2262 case INTEGER:
2263 case INTERFACE:
2264 case INTERSECT:
2265 case INTERVAL:
2266 case INTO:
2267 case INVALIDATE:
2268 case IS:
2269 case ISOLATION:
2270 case JAVA:
2271 case LEVEL:
2272 case LIKE:
2273 case LIMIT:
2274 case LIMITED:
2275 case LOCK:
2276 case LONG:
2277 case LOOP:
2278 case MAP:
2279 case MAX:
2280 case MEMBER:
2281 case MERGE:
2282 case MIN:
2283 case MINUS:
2284 case MINUTE:
2285 case MLSLABEL:
2286 case MODIFY:
2287 case MOD:
2288 case MODE:
2289 case MONTH:
2290 case NATURAL:
2291 case NATURALN:
2292 case NEW:
2293 case NEXTVAL:
2294 case NO:
2295 case NOCOPY:
2296 case NONEDITIONABLE:
2297 case NOT:
2298 case NOWAIT:
2299 case NULL:
2300 case NULLIF:
2301 case NUMBER:
2302 case BFILE_BASE:
2303 case BLOB_BASE:
2304 case CLOB_BASE:
2305 case DATE_BASE:
2306 case NUMBER_BASE:
2307 case OBJECT:
2308 case OCIROWID:
2309 case OF:
2310 case OID:
2311 case ON:
2312 case OPAQUE:
2313 case OPEN:
2314 case OPERATOR:
2315 case OPTION:
2316 case OR:
2317 case ORDER:
2318 case ORGANIZATION:
2319 case OTHERS:
2320 case OUT:
2321 case OVERRIDING:
2322 case PACKAGE:
2323 case PARTITION:
2324 case PCTFREE:
2325 case PLS_INTEGER:
2326 case POSITIVE:
2327 case POSITIVEN:
2328 case PRAGMA:
2329 case PRESERVE:
2330 case PRIOR:
2331 case PROMPT:
2332 case PRIVATE:
2333 case PROCEDURE:
2334 case PUBLIC:
2335 case RAISE:
2336 case RANGE:
2337 case RAW:
2338 case REAL:
2339 case RECORD:
2340 case REF:
2341 case RELEASE:
2342 case RELIES_ON:
2343 case RENAME:
2344 case RESULT:
2345 case RETURN:
2346 case RETURNING:
2347 case REVERSE:
2348 case ROLLBACK:
2349 case ROW:
2350 case ROWS:
2351 case ROWID:
2352 case ROWNUM:
2353 case ROWTYPE:
2354 case SAVE:
2355 case SAVEPOINT:
2356 case SECOND:
2357 case SELECT:
2358 case SELF:
2359 case SEPARATE:
2360 case SET:
2361 case SHARE:
2362 case SMALLINT:
2363 case SPACE:
2364 case SQL:
2365 case SQLCODE:
2366 case SQLERRM:
2367 case START:
2368 case STATIC:
2369 case STDDEV:
2370 case SUBTYPE:
2371 case SUBSTITUTABLE:
2372 case SUCCESSFUL:
2373 case SUM:
2374 case SYNONYM:
2375 case SYSDATE:
2376 case SYS_REFCURSOR:
2377 case TABLE:
2378 case TEMPORARY:
2379 case THEN:
2380 case TIME:
2381 case TIMESTAMP:
2382 case TIMEZONE_REGION:
2383 case TIMEZONE_ABBR:
2384 case TIMEZONE_MINUTE:
2385 case TIMEZONE_HOUR:
2386 case TO:
2387 case TRANSACTION:
2388 case TRIGGER:
2389 case TRUE:
2390 case TYPE:
2391 case UI:
2392 case UNDER:
2393 case USING:
2394 case WHILE:
2395 case YES:
2396 case SHOW:
2397 case A:
2398 case UPDATE:
2399 case VARCHAR:
2400 case VARCHAR2:
2401 case DOUBLE:
2402 case DEC:
2403 case PRECISION:
2404 case INT:
2405 case NUMERIC:
2406 case SIGNTYPE:
2407 case NCHAR:
2408 case NVARCHAR2:
2409 case STRING:
2410 case UROWID:
2411 case VARRAY:
2412 case VARYING:
2413 case BFILE:
2414 case BLOB:
2415 case CLOB:
2416 case NCLOB:
2417 case YEAR:
2418 case LOCAL:
2419 case WITH:
2420 case ZONE:
2421 case CHARACTER:
2422 case AFTER:
2423 case BEFORE:
2424 case OLD:
2425 case PARENT:
2426 case CC_IF:
2427 case ANALYZE:
2428 case ASSOCIATE:
2429 case AUDIT:
2430 case COMPOUND:
2431 case DATABASE:
2432 case CALL:
2433 case DDL:
2434 case DISASSOCIATE:
2435 case EACH:
2436 case FOLLOWS:
2437 case LOGOFF:
2438 case LOGON:
2439 case NESTED:
2440 case NOAUDIT:
2441 case SCHEMA:
2442 case SERVERERROR:
2443 case SHUTDOWN:
2444 case STARTUP:
2445 case STATEMENT:
2446 case STATISTICS:
2447 case SUSPEND:
2448 case TRUNCATE:
2449 case WRAPPED:
2450 case LIBRARY:
2451 case NAME:
2452 case STRUCT:
2453 case CONTEXT:
2454 case PARAMETERS:
2455 case LENGTH:
2456 case TDO:
2457 case MAXLEN:
2458 case CHARSETID:
2459 case CHARSETFORM:
2460 case ACCEPT:
2461 case ACCESSIBLE:
2462 case COPY:
2463 case DEFINE:
2464 case DISCONNECT:
2465 case HOST:
2466 case PRINT:
2467 case QUIT:
2468 case REMARK:
2469 case UNDEFINE:
2470 case VARIABLE:
2471 case WHENEVER:
2472 case ATTACH:
2473 case CAST:
2474 case TREAT:
2475 case TRIM:
2476 case LEFT:
2477 case RIGHT:
2478 case BOTH:
2479 case EMPTY:
2480 case MULTISET:
2481 case SUBMULTISET:
2482 case LEADING:
2483 case TRAILING:
2484 case CHAR_CS:
2485 case NCHAR_CS:
2486 case DBTIMEZONE:
2487 case SESSIONTIMEZONE:
2488 case AUTHENTICATED:
2489 case LINK:
2490 case SHARED:
2491 case DIRECTORY:
2492 case USER:
2493 case IDENTIFIER:
2494 case QUOTED_LITERAL:
2495 case SQLDATA_CLASS:
2496 case CUSTOMDATUM_CLASS:
2497 case ORADATA_CLASS:
2498 case JAVA_INTERFACE_CLASS:
2499 ;
2500 break;
2501 default:
2502 jj_la1[33] = jj_gen;
2503 break label_7;
2504 }
2505 DeclarativeUnit();
2506 }
2507 jjtree.closeNodeScope(jjtn000, true);
2508 jjtc000 = false;
2509 {if (true) return jjtn000 ;}
2510 } catch (Throwable jjte000) {
2511 if (jjtc000) {
2512 jjtree.clearNodeScope(jjtn000);
2513 jjtc000 = false;
2514 } else {
2515 jjtree.popNode();
2516 }
2517 if (jjte000 instanceof RuntimeException) {
2518 {if (true) throw (RuntimeException)jjte000;}
2519 }
2520 if (jjte000 instanceof ParseException) {
2521 {if (true) throw (ParseException)jjte000;}
2522 }
2523 {if (true) throw (Error)jjte000;}
2524 } finally {
2525 if (jjtc000) {
2526 jjtree.closeNodeScope(jjtn000, true);
2527 }
2528 }
2529 throw new Error("Missing return statement in function");
2530 }
2531
2532 final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533
2534 ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535 boolean jjtc000 = true;
2536 jjtree.openNodeScope(jjtn000);
2537 try {
2538 jj_consume_token(CC_IF);
2539 ConditionalOrExpression();
2540 jj_consume_token(CC_THEN);
2541 label_8:
2542 while (true) {
2543 switch (jj_nt.kind) {
2544 case REPLACE:
2545 case DEFINER:
2546 case CURRENT_USER:
2547 case SERIALLY_REUSABLE:
2548 case RESTRICT_REFERENCES:
2549 case EXCEPTION_INIT:
2550 case AUTONOMOUS_TRANSACTION:
2551 case LANGUAGE:
2552 case INLINE:
2553 case ADD:
2554 case AGGREGATE:
2555 case ALL:
2556 case ALTER:
2557 case AND:
2558 case ANY:
2559 case ARRAY:
2560 case AS:
2561 case ASC:
2562 case AT:
2563 case ATTRIBUTE:
2564 case AUTHID:
2565 case AVG:
2566 case BETWEEN:
2567 case BINARY_INTEGER:
2568 case BODY:
2569 case BOOLEAN:
2570 case BULK:
2571 case BY:
2572 case BYTE:
2573 case CASCADE:
2574 case CASE:
2575 case CHAR:
2576 case CHAR_BASE:
2577 case CHECK:
2578 case CLOSE:
2579 case CLUSTER:
2580 case COALESCE:
2581 case COLLECT:
2582 case COLUMN:
2583 case COMMENT:
2584 case COMMIT:
2585 case COMPRESS:
2586 case CONNECT:
2587 case CONSTANT:
2588 case CONSTRUCTOR:
2589 case CONTINUE:
2590 case CONVERT:
2591 case CREATE:
2592 case CURRENT:
2593 case CURRVAL:
2594 case CURSOR:
2595 case DATA:
2596 case DATE:
2597 case DAY:
2598 case DECLARE:
2599 case DECIMAL:
2600 case _DEFAULT:
2601 case DELETE:
2602 case DESC:
2603 case DISABLE:
2604 case DISTINCT:
2605 case DO:
2606 case DROP:
2607 case EDITIONABLE:
2608 case ELEMENT:
2609 case ELSE:
2610 case ELSIF:
2611 case ENABLE:
2612 case ESCAPE:
2613 case EXCEPT:
2614 case EXCEPTION:
2615 case EXCEPTIONS:
2616 case EXCLUSIVE:
2617 case EXECUTE:
2618 case EXISTS:
2619 case EXIT:
2620 case EXTERNAL:
2621 case EXTENDS:
2622 case EXTRACT:
2623 case FALSE:
2624 case FETCH:
2625 case FINAL:
2626 case FLOAT:
2627 case FOR:
2628 case FORALL:
2629 case FORCE:
2630 case FROM:
2631 case FUNCTION:
2632 case GLOBAL:
2633 case GOTO:
2634 case GROUP:
2635 case HASH:
2636 case HAVING:
2637 case HEAP:
2638 case HOUR:
2639 case IF:
2640 case IMMEDIATE:
2641 case IN:
2642 case INDEX:
2643 case INDICES:
2644 case INDEXTYPE:
2645 case INDICATOR:
2646 case INSERT:
2647 case INSTANTIABLE:
2648 case INTEGER:
2649 case INTERFACE:
2650 case INTERSECT:
2651 case INTERVAL:
2652 case INTO:
2653 case INVALIDATE:
2654 case IS:
2655 case ISOLATION:
2656 case JAVA:
2657 case LEVEL:
2658 case LIKE:
2659 case LIMIT:
2660 case LIMITED:
2661 case LOCK:
2662 case LONG:
2663 case LOOP:
2664 case MAP:
2665 case MAX:
2666 case MEMBER:
2667 case MERGE:
2668 case MIN:
2669 case MINUS:
2670 case MINUTE:
2671 case MLSLABEL:
2672 case MODIFY:
2673 case MOD:
2674 case MODE:
2675 case MONTH:
2676 case NATURAL:
2677 case NATURALN:
2678 case NEW:
2679 case NEXTVAL:
2680 case NO:
2681 case NOCOPY:
2682 case NONEDITIONABLE:
2683 case NOT:
2684 case NOWAIT:
2685 case NULL:
2686 case NULLIF:
2687 case NUMBER:
2688 case BFILE_BASE:
2689 case BLOB_BASE:
2690 case CLOB_BASE:
2691 case DATE_BASE:
2692 case NUMBER_BASE:
2693 case OBJECT:
2694 case OCIROWID:
2695 case OF:
2696 case OID:
2697 case ON:
2698 case OPAQUE:
2699 case OPEN:
2700 case OPERATOR:
2701 case OPTION:
2702 case OR:
2703 case ORDER:
2704 case ORGANIZATION:
2705 case OTHERS:
2706 case OUT:
2707 case OVERRIDING:
2708 case PACKAGE:
2709 case PARTITION:
2710 case PCTFREE:
2711 case PLS_INTEGER:
2712 case POSITIVE:
2713 case POSITIVEN:
2714 case PRAGMA:
2715 case PRESERVE:
2716 case PRIOR:
2717 case PROMPT:
2718 case PRIVATE:
2719 case PROCEDURE:
2720 case PUBLIC:
2721 case RAISE:
2722 case RANGE:
2723 case RAW:
2724 case REAL:
2725 case RECORD:
2726 case REF:
2727 case RELEASE:
2728 case RELIES_ON:
2729 case RENAME:
2730 case RESULT:
2731 case RETURN:
2732 case RETURNING:
2733 case REVERSE:
2734 case ROLLBACK:
2735 case ROW:
2736 case ROWS:
2737 case ROWID:
2738 case ROWNUM:
2739 case ROWTYPE:
2740 case SAVE:
2741 case SAVEPOINT:
2742 case SECOND:
2743 case SELECT:
2744 case SELF:
2745 case SEPARATE:
2746 case SET:
2747 case SHARE:
2748 case SMALLINT:
2749 case SPACE:
2750 case SQL:
2751 case SQLCODE:
2752 case SQLERRM:
2753 case START:
2754 case STATIC:
2755 case STDDEV:
2756 case SUBTYPE:
2757 case SUBSTITUTABLE:
2758 case SUCCESSFUL:
2759 case SUM:
2760 case SYNONYM:
2761 case SYSDATE:
2762 case SYS_REFCURSOR:
2763 case TABLE:
2764 case TEMPORARY:
2765 case THEN:
2766 case TIME:
2767 case TIMESTAMP:
2768 case TIMEZONE_REGION:
2769 case TIMEZONE_ABBR:
2770 case TIMEZONE_MINUTE:
2771 case TIMEZONE_HOUR:
2772 case TO:
2773 case TRANSACTION:
2774 case TRIGGER:
2775 case TRUE:
2776 case TYPE:
2777 case UI:
2778 case UNDER:
2779 case USING:
2780 case WHILE:
2781 case YES:
2782 case SHOW:
2783 case A:
2784 case UPDATE:
2785 case VARCHAR:
2786 case VARCHAR2:
2787 case DOUBLE:
2788 case DEC:
2789 case PRECISION:
2790 case INT:
2791 case NUMERIC:
2792 case SIGNTYPE:
2793 case NCHAR:
2794 case NVARCHAR2:
2795 case STRING:
2796 case UROWID:
2797 case VARRAY:
2798 case VARYING:
2799 case BFILE:
2800 case BLOB:
2801 case CLOB:
2802 case NCLOB:
2803 case YEAR:
2804 case LOCAL:
2805 case WITH:
2806 case ZONE:
2807 case CHARACTER:
2808 case AFTER:
2809 case BEFORE:
2810 case OLD:
2811 case PARENT:
2812 case CC_IF:
2813 case CC_ERROR:
2814 case ANALYZE:
2815 case ASSOCIATE:
2816 case AUDIT:
2817 case COMPOUND:
2818 case DATABASE:
2819 case CALL:
2820 case DDL:
2821 case DISASSOCIATE:
2822 case EACH:
2823 case FOLLOWS:
2824 case LOGOFF:
2825 case LOGON:
2826 case NESTED:
2827 case NOAUDIT:
2828 case SCHEMA:
2829 case SERVERERROR:
2830 case SHUTDOWN:
2831 case STARTUP:
2832 case STATEMENT:
2833 case STATISTICS:
2834 case SUSPEND:
2835 case TRUNCATE:
2836 case WRAPPED:
2837 case LIBRARY:
2838 case NAME:
2839 case STRUCT:
2840 case CONTEXT:
2841 case PARAMETERS:
2842 case LENGTH:
2843 case TDO:
2844 case MAXLEN:
2845 case CHARSETID:
2846 case CHARSETFORM:
2847 case ACCEPT:
2848 case ACCESSIBLE:
2849 case COPY:
2850 case DEFINE:
2851 case DISCONNECT:
2852 case HOST:
2853 case PRINT:
2854 case QUIT:
2855 case REMARK:
2856 case UNDEFINE:
2857 case VARIABLE:
2858 case WHENEVER:
2859 case ATTACH:
2860 case CAST:
2861 case TREAT:
2862 case TRIM:
2863 case LEFT:
2864 case RIGHT:
2865 case BOTH:
2866 case EMPTY:
2867 case MULTISET:
2868 case SUBMULTISET:
2869 case LEADING:
2870 case TRAILING:
2871 case CHAR_CS:
2872 case NCHAR_CS:
2873 case DBTIMEZONE:
2874 case SESSIONTIMEZONE:
2875 case AUTHENTICATED:
2876 case LINK:
2877 case SHARED:
2878 case DIRECTORY:
2879 case USER:
2880 case IDENTIFIER:
2881 case QUOTED_LITERAL:
2882 case SQLDATA_CLASS:
2883 case CUSTOMDATUM_CLASS:
2884 case ORADATA_CLASS:
2885 case JAVA_INTERFACE_CLASS:
2886 ;
2887 break;
2888 default:
2889 jj_la1[34] = jj_gen;
2890 break label_8;
2891 }
2892 switch (jj_nt.kind) {
2893 case REPLACE:
2894 case DEFINER:
2895 case CURRENT_USER:
2896 case SERIALLY_REUSABLE:
2897 case RESTRICT_REFERENCES:
2898 case EXCEPTION_INIT:
2899 case AUTONOMOUS_TRANSACTION:
2900 case LANGUAGE:
2901 case INLINE:
2902 case ADD:
2903 case AGGREGATE:
2904 case ALL:
2905 case ALTER:
2906 case AND:
2907 case ANY:
2908 case ARRAY:
2909 case AS:
2910 case ASC:
2911 case AT:
2912 case ATTRIBUTE:
2913 case AUTHID:
2914 case AVG:
2915 case BETWEEN:
2916 case BINARY_INTEGER:
2917 case BODY:
2918 case BOOLEAN:
2919 case BULK:
2920 case BY:
2921 case BYTE:
2922 case CASCADE:
2923 case CASE:
2924 case CHAR:
2925 case CHAR_BASE:
2926 case CHECK:
2927 case CLOSE:
2928 case CLUSTER:
2929 case COALESCE:
2930 case COLLECT:
2931 case COLUMN:
2932 case COMMENT:
2933 case COMMIT:
2934 case COMPRESS:
2935 case CONNECT:
2936 case CONSTANT:
2937 case CONSTRUCTOR:
2938 case CONTINUE:
2939 case CONVERT:
2940 case CREATE:
2941 case CURRENT:
2942 case CURRVAL:
2943 case CURSOR:
2944 case DATA:
2945 case DATE:
2946 case DAY:
2947 case DECLARE:
2948 case DECIMAL:
2949 case _DEFAULT:
2950 case DELETE:
2951 case DESC:
2952 case DISABLE:
2953 case DISTINCT:
2954 case DO:
2955 case DROP:
2956 case EDITIONABLE:
2957 case ELEMENT:
2958 case ELSE:
2959 case ELSIF:
2960 case ENABLE:
2961 case ESCAPE:
2962 case EXCEPT:
2963 case EXCEPTION:
2964 case EXCEPTIONS:
2965 case EXCLUSIVE:
2966 case EXECUTE:
2967 case EXISTS:
2968 case EXIT:
2969 case EXTERNAL:
2970 case EXTENDS:
2971 case EXTRACT:
2972 case FALSE:
2973 case FETCH:
2974 case FINAL:
2975 case FLOAT:
2976 case FOR:
2977 case FORALL:
2978 case FORCE:
2979 case FROM:
2980 case FUNCTION:
2981 case GLOBAL:
2982 case GOTO:
2983 case GROUP:
2984 case HASH:
2985 case HAVING:
2986 case HEAP:
2987 case HOUR:
2988 case IF:
2989 case IMMEDIATE:
2990 case IN:
2991 case INDEX:
2992 case INDICES:
2993 case INDEXTYPE:
2994 case INDICATOR:
2995 case INSERT:
2996 case INSTANTIABLE:
2997 case INTEGER:
2998 case INTERFACE:
2999 case INTERSECT:
3000 case INTERVAL:
3001 case INTO:
3002 case INVALIDATE:
3003 case IS:
3004 case ISOLATION:
3005 case JAVA:
3006 case LEVEL:
3007 case LIKE:
3008 case LIMIT:
3009 case LIMITED:
3010 case LOCK:
3011 case LONG:
3012 case LOOP:
3013 case MAP:
3014 case MAX:
3015 case MEMBER:
3016 case MERGE:
3017 case MIN:
3018 case MINUS:
3019 case MINUTE:
3020 case MLSLABEL:
3021 case MODIFY:
3022 case MOD:
3023 case MODE:
3024 case MONTH:
3025 case NATURAL:
3026 case NATURALN:
3027 case NEW:
3028 case NEXTVAL:
3029 case NO:
3030 case NOCOPY:
3031 case NONEDITIONABLE:
3032 case NOT:
3033 case NOWAIT:
3034 case NULL:
3035 case NULLIF:
3036 case NUMBER:
3037 case BFILE_BASE:
3038 case BLOB_BASE:
3039 case CLOB_BASE:
3040 case DATE_BASE:
3041 case NUMBER_BASE:
3042 case OBJECT:
3043 case OCIROWID:
3044 case OF:
3045 case OID:
3046 case ON:
3047 case OPAQUE:
3048 case OPEN:
3049 case OPERATOR:
3050 case OPTION:
3051 case OR:
3052 case ORDER:
3053 case ORGANIZATION:
3054 case OTHERS:
3055 case OUT:
3056 case OVERRIDING:
3057 case PACKAGE:
3058 case PARTITION:
3059 case PCTFREE:
3060 case PLS_INTEGER:
3061 case POSITIVE:
3062 case POSITIVEN:
3063 case PRAGMA:
3064 case PRESERVE:
3065 case PRIOR:
3066 case PROMPT:
3067 case PRIVATE:
3068 case PROCEDURE:
3069 case PUBLIC:
3070 case RAISE:
3071 case RANGE:
3072 case RAW:
3073 case REAL:
3074 case RECORD:
3075 case REF:
3076 case RELEASE:
3077 case RELIES_ON:
3078 case RENAME:
3079 case RESULT:
3080 case RETURN:
3081 case RETURNING:
3082 case REVERSE:
3083 case ROLLBACK:
3084 case ROW:
3085 case ROWS:
3086 case ROWID:
3087 case ROWNUM:
3088 case ROWTYPE:
3089 case SAVE:
3090 case SAVEPOINT:
3091 case SECOND:
3092 case SELECT:
3093 case SELF:
3094 case SEPARATE:
3095 case SET:
3096 case SHARE:
3097 case SMALLINT:
3098 case SPACE:
3099 case SQL:
3100 case SQLCODE:
3101 case SQLERRM:
3102 case START:
3103 case STATIC:
3104 case STDDEV:
3105 case SUBTYPE:
3106 case SUBSTITUTABLE:
3107 case SUCCESSFUL:
3108 case SUM:
3109 case SYNONYM:
3110 case SYSDATE:
3111 case SYS_REFCURSOR:
3112 case TABLE:
3113 case TEMPORARY:
3114 case THEN:
3115 case TIME:
3116 case TIMESTAMP:
3117 case TIMEZONE_REGION:
3118 case TIMEZONE_ABBR:
3119 case TIMEZONE_MINUTE:
3120 case TIMEZONE_HOUR:
3121 case TO:
3122 case TRANSACTION:
3123 case TRIGGER:
3124 case TRUE:
3125 case TYPE:
3126 case UI:
3127 case UNDER:
3128 case USING:
3129 case WHILE:
3130 case YES:
3131 case SHOW:
3132 case A:
3133 case UPDATE:
3134 case VARCHAR:
3135 case VARCHAR2:
3136 case DOUBLE:
3137 case DEC:
3138 case PRECISION:
3139 case INT:
3140 case NUMERIC:
3141 case SIGNTYPE:
3142 case NCHAR:
3143 case NVARCHAR2:
3144 case STRING:
3145 case UROWID:
3146 case VARRAY:
3147 case VARYING:
3148 case BFILE:
3149 case BLOB:
3150 case CLOB:
3151 case NCLOB:
3152 case YEAR:
3153 case LOCAL:
3154 case WITH:
3155 case ZONE:
3156 case CHARACTER:
3157 case AFTER:
3158 case BEFORE:
3159 case OLD:
3160 case PARENT:
3161 case CC_IF:
3162 case ANALYZE:
3163 case ASSOCIATE:
3164 case AUDIT:
3165 case COMPOUND:
3166 case DATABASE:
3167 case CALL:
3168 case DDL:
3169 case DISASSOCIATE:
3170 case EACH:
3171 case FOLLOWS:
3172 case LOGOFF:
3173 case LOGON:
3174 case NESTED:
3175 case NOAUDIT:
3176 case SCHEMA:
3177 case SERVERERROR:
3178 case SHUTDOWN:
3179 case STARTUP:
3180 case STATEMENT:
3181 case STATISTICS:
3182 case SUSPEND:
3183 case TRUNCATE:
3184 case WRAPPED:
3185 case LIBRARY:
3186 case NAME:
3187 case STRUCT:
3188 case CONTEXT:
3189 case PARAMETERS:
3190 case LENGTH:
3191 case TDO:
3192 case MAXLEN:
3193 case CHARSETID:
3194 case CHARSETFORM:
3195 case ACCEPT:
3196 case ACCESSIBLE:
3197 case COPY:
3198 case DEFINE:
3199 case DISCONNECT:
3200 case HOST:
3201 case PRINT:
3202 case QUIT:
3203 case REMARK:
3204 case UNDEFINE:
3205 case VARIABLE:
3206 case WHENEVER:
3207 case ATTACH:
3208 case CAST:
3209 case TREAT:
3210 case TRIM:
3211 case LEFT:
3212 case RIGHT:
3213 case BOTH:
3214 case EMPTY:
3215 case MULTISET:
3216 case SUBMULTISET:
3217 case LEADING:
3218 case TRAILING:
3219 case CHAR_CS:
3220 case NCHAR_CS:
3221 case DBTIMEZONE:
3222 case SESSIONTIMEZONE:
3223 case AUTHENTICATED:
3224 case LINK:
3225 case SHARED:
3226 case DIRECTORY:
3227 case USER:
3228 case IDENTIFIER:
3229 case QUOTED_LITERAL:
3230 case SQLDATA_CLASS:
3231 case CUSTOMDATUM_CLASS:
3232 case ORADATA_CLASS:
3233 case JAVA_INTERFACE_CLASS:
3234 DeclarativeUnit();
3235 break;
3236 case CC_ERROR:
3237 jj_consume_token(CC_ERROR);
3238 Expression();
3239 jj_consume_token(CC_END);
3240 break;
3241 default:
3242 jj_la1[35] = jj_gen;
3243 jj_consume_token(-1);
3244 throw new ParseException();
3245 }
3246 }
3247 label_9:
3248 while (true) {
3249 switch (jj_nt.kind) {
3250 case CC_ELSIF:
3251 ;
3252 break;
3253 default:
3254 jj_la1[36] = jj_gen;
3255 break label_9;
3256 }
3257 jj_consume_token(CC_ELSIF);
3258 ConditionalOrExpression();
3259 jj_consume_token(CC_THEN);
3260 label_10:
3261 while (true) {
3262 switch (jj_nt.kind) {
3263 case REPLACE:
3264 case DEFINER:
3265 case CURRENT_USER:
3266 case SERIALLY_REUSABLE:
3267 case RESTRICT_REFERENCES:
3268 case EXCEPTION_INIT:
3269 case AUTONOMOUS_TRANSACTION:
3270 case LANGUAGE:
3271 case INLINE:
3272 case ADD:
3273 case AGGREGATE:
3274 case ALL:
3275 case ALTER:
3276 case AND:
3277 case ANY:
3278 case ARRAY:
3279 case AS:
3280 case ASC:
3281 case AT:
3282 case ATTRIBUTE:
3283 case AUTHID:
3284 case AVG:
3285 case BETWEEN:
3286 case BINARY_INTEGER:
3287 case BODY:
3288 case BOOLEAN:
3289 case BULK:
3290 case BY:
3291 case BYTE:
3292 case CASCADE:
3293 case CASE:
3294 case CHAR:
3295 case CHAR_BASE:
3296 case CHECK:
3297 case CLOSE:
3298 case CLUSTER:
3299 case COALESCE:
3300 case COLLECT:
3301 case COLUMN:
3302 case COMMENT:
3303 case COMMIT:
3304 case COMPRESS:
3305 case CONNECT:
3306 case CONSTANT:
3307 case CONSTRUCTOR:
3308 case CONTINUE:
3309 case CONVERT:
3310 case CREATE:
3311 case CURRENT:
3312 case CURRVAL:
3313 case CURSOR:
3314 case DATA:
3315 case DATE:
3316 case DAY:
3317 case DECLARE:
3318 case DECIMAL:
3319 case _DEFAULT:
3320 case DELETE:
3321 case DESC:
3322 case DISABLE:
3323 case DISTINCT:
3324 case DO:
3325 case DROP:
3326 case EDITIONABLE:
3327 case ELEMENT:
3328 case ELSE:
3329 case ELSIF:
3330 case ENABLE:
3331 case ESCAPE:
3332 case EXCEPT:
3333 case EXCEPTION:
3334 case EXCEPTIONS:
3335 case EXCLUSIVE:
3336 case EXECUTE:
3337 case EXISTS:
3338 case EXIT:
3339 case EXTERNAL:
3340 case EXTENDS:
3341 case EXTRACT:
3342 case FALSE:
3343 case FETCH:
3344 case FINAL:
3345 case FLOAT:
3346 case FOR:
3347 case FORALL:
3348 case FORCE:
3349 case FROM:
3350 case FUNCTION:
3351 case GLOBAL:
3352 case GOTO:
3353 case GROUP:
3354 case HASH:
3355 case HAVING:
3356 case HEAP:
3357 case HOUR:
3358 case IF:
3359 case IMMEDIATE:
3360 case IN:
3361 case INDEX:
3362 case INDICES:
3363 case INDEXTYPE:
3364 case INDICATOR:
3365 case INSERT:
3366 case INSTANTIABLE:
3367 case INTEGER:
3368 case INTERFACE:
3369 case INTERSECT:
3370 case INTERVAL:
3371 case INTO:
3372 case INVALIDATE:
3373 case IS:
3374 case ISOLATION:
3375 case JAVA:
3376 case LEVEL:
3377 case LIKE:
3378 case LIMIT:
3379 case LIMITED:
3380 case LOCK:
3381 case LONG:
3382 case LOOP:
3383 case MAP:
3384 case MAX:
3385 case MEMBER:
3386 case MERGE:
3387 case MIN:
3388 case MINUS:
3389 case MINUTE:
3390 case MLSLABEL:
3391 case MODIFY:
3392 case MOD:
3393 case MODE:
3394 case MONTH:
3395 case NATURAL:
3396 case NATURALN:
3397 case NEW:
3398 case NEXTVAL:
3399 case NO:
3400 case NOCOPY:
3401 case NONEDITIONABLE:
3402 case NOT:
3403 case NOWAIT:
3404 case NULL:
3405 case NULLIF:
3406 case NUMBER:
3407 case BFILE_BASE:
3408 case BLOB_BASE:
3409 case CLOB_BASE:
3410 case DATE_BASE:
3411 case NUMBER_BASE:
3412 case OBJECT:
3413 case OCIROWID:
3414 case OF:
3415 case OID:
3416 case ON:
3417 case OPAQUE:
3418 case OPEN:
3419 case OPERATOR:
3420 case OPTION:
3421 case OR:
3422 case ORDER:
3423 case ORGANIZATION:
3424 case OTHERS:
3425 case OUT:
3426 case OVERRIDING:
3427 case PACKAGE:
3428 case PARTITION:
3429 case PCTFREE:
3430 case PLS_INTEGER:
3431 case POSITIVE:
3432 case POSITIVEN:
3433 case PRAGMA:
3434 case PRESERVE:
3435 case PRIOR:
3436 case PROMPT:
3437 case PRIVATE:
3438 case PROCEDURE:
3439 case PUBLIC:
3440 case RAISE:
3441 case RANGE:
3442 case RAW:
3443 case REAL:
3444 case RECORD:
3445 case REF:
3446 case RELEASE:
3447 case RELIES_ON:
3448 case RENAME:
3449 case RESULT:
3450 case RETURN:
3451 case RETURNING:
3452 case REVERSE:
3453 case ROLLBACK:
3454 case ROW:
3455 case ROWS:
3456 case ROWID:
3457 case ROWNUM:
3458 case ROWTYPE:
3459 case SAVE:
3460 case SAVEPOINT:
3461 case SECOND:
3462 case SELECT:
3463 case SELF:
3464 case SEPARATE:
3465 case SET:
3466 case SHARE:
3467 case SMALLINT:
3468 case SPACE:
3469 case SQL:
3470 case SQLCODE:
3471 case SQLERRM:
3472 case START:
3473 case STATIC:
3474 case STDDEV:
3475 case SUBTYPE:
3476 case SUBSTITUTABLE:
3477 case SUCCESSFUL:
3478 case SUM:
3479 case SYNONYM:
3480 case SYSDATE:
3481 case SYS_REFCURSOR:
3482 case TABLE:
3483 case TEMPORARY:
3484 case THEN:
3485 case TIME:
3486 case TIMESTAMP:
3487 case TIMEZONE_REGION:
3488 case TIMEZONE_ABBR:
3489 case TIMEZONE_MINUTE:
3490 case TIMEZONE_HOUR:
3491 case TO:
3492 case TRANSACTION:
3493 case TRIGGER:
3494 case TRUE:
3495 case TYPE:
3496 case UI:
3497 case UNDER:
3498 case USING:
3499 case WHILE:
3500 case YES:
3501 case SHOW:
3502 case A:
3503 case UPDATE:
3504 case VARCHAR:
3505 case VARCHAR2:
3506 case DOUBLE:
3507 case DEC:
3508 case PRECISION:
3509 case INT:
3510 case NUMERIC:
3511 case SIGNTYPE:
3512 case NCHAR:
3513 case NVARCHAR2:
3514 case STRING:
3515 case UROWID:
3516 case VARRAY:
3517 case VARYING:
3518 case BFILE:
3519 case BLOB:
3520 case CLOB:
3521 case NCLOB:
3522 case YEAR:
3523 case LOCAL:
3524 case WITH:
3525 case ZONE:
3526 case CHARACTER:
3527 case AFTER:
3528 case BEFORE:
3529 case OLD:
3530 case PARENT:
3531 case CC_IF:
3532 case CC_ERROR:
3533 case ANALYZE:
3534 case ASSOCIATE:
3535 case AUDIT:
3536 case COMPOUND:
3537 case DATABASE:
3538 case CALL:
3539 case DDL:
3540 case DISASSOCIATE:
3541 case EACH:
3542 case FOLLOWS:
3543 case LOGOFF:
3544 case LOGON:
3545 case NESTED:
3546 case NOAUDIT:
3547 case SCHEMA:
3548 case SERVERERROR:
3549 case SHUTDOWN:
3550 case STARTUP:
3551 case STATEMENT:
3552 case STATISTICS:
3553 case SUSPEND:
3554 case TRUNCATE:
3555 case WRAPPED:
3556 case LIBRARY:
3557 case NAME:
3558 case STRUCT:
3559 case CONTEXT:
3560 case PARAMETERS:
3561 case LENGTH:
3562 case TDO:
3563 case MAXLEN:
3564 case CHARSETID:
3565 case CHARSETFORM:
3566 case ACCEPT:
3567 case ACCESSIBLE:
3568 case COPY:
3569 case DEFINE:
3570 case DISCONNECT:
3571 case HOST:
3572 case PRINT:
3573 case QUIT:
3574 case REMARK:
3575 case UNDEFINE:
3576 case VARIABLE:
3577 case WHENEVER:
3578 case ATTACH:
3579 case CAST:
3580 case TREAT:
3581 case TRIM:
3582 case LEFT:
3583 case RIGHT:
3584 case BOTH:
3585 case EMPTY:
3586 case MULTISET:
3587 case SUBMULTISET:
3588 case LEADING:
3589 case TRAILING:
3590 case CHAR_CS:
3591 case NCHAR_CS:
3592 case DBTIMEZONE:
3593 case SESSIONTIMEZONE:
3594 case AUTHENTICATED:
3595 case LINK:
3596 case SHARED:
3597 case DIRECTORY:
3598 case USER:
3599 case IDENTIFIER:
3600 case QUOTED_LITERAL:
3601 case SQLDATA_CLASS:
3602 case CUSTOMDATUM_CLASS:
3603 case ORADATA_CLASS:
3604 case JAVA_INTERFACE_CLASS:
3605 ;
3606 break;
3607 default:
3608 jj_la1[37] = jj_gen;
3609 break label_10;
3610 }
3611 switch (jj_nt.kind) {
3612 case REPLACE:
3613 case DEFINER:
3614 case CURRENT_USER:
3615 case SERIALLY_REUSABLE:
3616 case RESTRICT_REFERENCES:
3617 case EXCEPTION_INIT:
3618 case AUTONOMOUS_TRANSACTION:
3619 case LANGUAGE:
3620 case INLINE:
3621 case ADD:
3622 case AGGREGATE:
3623 case ALL:
3624 case ALTER:
3625 case AND:
3626 case ANY:
3627 case ARRAY:
3628 case AS:
3629 case ASC:
3630 case AT:
3631 case ATTRIBUTE:
3632 case AUTHID:
3633 case AVG:
3634 case BETWEEN:
3635 case BINARY_INTEGER:
3636 case BODY:
3637 case BOOLEAN:
3638 case BULK:
3639 case BY:
3640 case BYTE:
3641 case CASCADE:
3642 case CASE:
3643 case CHAR:
3644 case CHAR_BASE:
3645 case CHECK:
3646 case CLOSE:
3647 case CLUSTER:
3648 case COALESCE:
3649 case COLLECT:
3650 case COLUMN:
3651 case COMMENT:
3652 case COMMIT:
3653 case COMPRESS:
3654 case CONNECT:
3655 case CONSTANT:
3656 case CONSTRUCTOR:
3657 case CONTINUE:
3658 case CONVERT:
3659 case CREATE:
3660 case CURRENT:
3661 case CURRVAL:
3662 case CURSOR:
3663 case DATA:
3664 case DATE:
3665 case DAY:
3666 case DECLARE:
3667 case DECIMAL:
3668 case _DEFAULT:
3669 case DELETE:
3670 case DESC:
3671 case DISABLE:
3672 case DISTINCT:
3673 case DO:
3674 case DROP:
3675 case EDITIONABLE:
3676 case ELEMENT:
3677 case ELSE:
3678 case ELSIF:
3679 case ENABLE:
3680 case ESCAPE:
3681 case EXCEPT:
3682 case EXCEPTION:
3683 case EXCEPTIONS:
3684 case EXCLUSIVE:
3685 case EXECUTE:
3686 case EXISTS:
3687 case EXIT:
3688 case EXTERNAL:
3689 case EXTENDS:
3690 case EXTRACT:
3691 case FALSE:
3692 case FETCH:
3693 case FINAL:
3694 case FLOAT:
3695 case FOR:
3696 case FORALL:
3697 case FORCE:
3698 case FROM:
3699 case FUNCTION:
3700 case GLOBAL:
3701 case GOTO:
3702 case GROUP:
3703 case HASH:
3704 case HAVING:
3705 case HEAP:
3706 case HOUR:
3707 case IF:
3708 case IMMEDIATE:
3709 case IN:
3710 case INDEX:
3711 case INDICES:
3712 case INDEXTYPE:
3713 case INDICATOR:
3714 case INSERT:
3715 case INSTANTIABLE:
3716 case INTEGER:
3717 case INTERFACE:
3718 case INTERSECT:
3719 case INTERVAL:
3720 case INTO:
3721 case INVALIDATE:
3722 case IS:
3723 case ISOLATION:
3724 case JAVA:
3725 case LEVEL:
3726 case LIKE:
3727 case LIMIT:
3728 case LIMITED:
3729 case LOCK:
3730 case LONG:
3731 case LOOP:
3732 case MAP:
3733 case MAX:
3734 case MEMBER:
3735 case MERGE:
3736 case MIN:
3737 case MINUS:
3738 case MINUTE:
3739 case MLSLABEL:
3740 case MODIFY:
3741 case MOD:
3742 case MODE:
3743 case MONTH:
3744 case NATURAL:
3745 case NATURALN:
3746 case NEW:
3747 case NEXTVAL:
3748 case NO:
3749 case NOCOPY:
3750 case NONEDITIONABLE:
3751 case NOT:
3752 case NOWAIT:
3753 case NULL:
3754 case NULLIF:
3755 case NUMBER:
3756 case BFILE_BASE:
3757 case BLOB_BASE:
3758 case CLOB_BASE:
3759 case DATE_BASE:
3760 case NUMBER_BASE:
3761 case OBJECT:
3762 case OCIROWID:
3763 case OF:
3764 case OID:
3765 case ON:
3766 case OPAQUE:
3767 case OPEN:
3768 case OPERATOR:
3769 case OPTION:
3770 case OR:
3771 case ORDER:
3772 case ORGANIZATION:
3773 case OTHERS:
3774 case OUT:
3775 case OVERRIDING:
3776 case PACKAGE:
3777 case PARTITION:
3778 case PCTFREE:
3779 case PLS_INTEGER:
3780 case POSITIVE:
3781 case POSITIVEN:
3782 case PRAGMA:
3783 case PRESERVE:
3784 case PRIOR:
3785 case PROMPT:
3786 case PRIVATE:
3787 case PROCEDURE:
3788 case PUBLIC:
3789 case RAISE:
3790 case RANGE:
3791 case RAW:
3792 case REAL:
3793 case RECORD:
3794 case REF:
3795 case RELEASE:
3796 case RELIES_ON:
3797 case RENAME:
3798 case RESULT:
3799 case RETURN:
3800 case RETURNING:
3801 case REVERSE:
3802 case ROLLBACK:
3803 case ROW:
3804 case ROWS:
3805 case ROWID:
3806 case ROWNUM:
3807 case ROWTYPE:
3808 case SAVE:
3809 case SAVEPOINT:
3810 case SECOND:
3811 case SELECT:
3812 case SELF:
3813 case SEPARATE:
3814 case SET:
3815 case SHARE:
3816 case SMALLINT:
3817 case SPACE:
3818 case SQL:
3819 case SQLCODE:
3820 case SQLERRM:
3821 case START:
3822 case STATIC:
3823 case STDDEV:
3824 case SUBTYPE:
3825 case SUBSTITUTABLE:
3826 case SUCCESSFUL:
3827 case SUM:
3828 case SYNONYM:
3829 case SYSDATE:
3830 case SYS_REFCURSOR:
3831 case TABLE:
3832 case TEMPORARY:
3833 case THEN:
3834 case TIME:
3835 case TIMESTAMP:
3836 case TIMEZONE_REGION:
3837 case TIMEZONE_ABBR:
3838 case TIMEZONE_MINUTE:
3839 case TIMEZONE_HOUR:
3840 case TO:
3841 case TRANSACTION:
3842 case TRIGGER:
3843 case TRUE:
3844 case TYPE:
3845 case UI:
3846 case UNDER:
3847 case USING:
3848 case WHILE:
3849 case YES:
3850 case SHOW:
3851 case A:
3852 case UPDATE:
3853 case VARCHAR:
3854 case VARCHAR2:
3855 case DOUBLE:
3856 case DEC:
3857 case PRECISION:
3858 case INT:
3859 case NUMERIC:
3860 case SIGNTYPE:
3861 case NCHAR:
3862 case NVARCHAR2:
3863 case STRING:
3864 case UROWID:
3865 case VARRAY:
3866 case VARYING:
3867 case BFILE:
3868 case BLOB:
3869 case CLOB:
3870 case NCLOB:
3871 case YEAR:
3872 case LOCAL:
3873 case WITH:
3874 case ZONE:
3875 case CHARACTER:
3876 case AFTER:
3877 case BEFORE:
3878 case OLD:
3879 case PARENT:
3880 case CC_IF:
3881 case ANALYZE:
3882 case ASSOCIATE:
3883 case AUDIT:
3884 case COMPOUND:
3885 case DATABASE:
3886 case CALL:
3887 case DDL:
3888 case DISASSOCIATE:
3889 case EACH:
3890 case FOLLOWS:
3891 case LOGOFF:
3892 case LOGON:
3893 case NESTED:
3894 case NOAUDIT:
3895 case SCHEMA:
3896 case SERVERERROR:
3897 case SHUTDOWN:
3898 case STARTUP:
3899 case STATEMENT:
3900 case STATISTICS:
3901 case SUSPEND:
3902 case TRUNCATE:
3903 case WRAPPED:
3904 case LIBRARY:
3905 case NAME:
3906 case STRUCT:
3907 case CONTEXT:
3908 case PARAMETERS:
3909 case LENGTH:
3910 case TDO:
3911 case MAXLEN:
3912 case CHARSETID:
3913 case CHARSETFORM:
3914 case ACCEPT:
3915 case ACCESSIBLE:
3916 case COPY:
3917 case DEFINE:
3918 case DISCONNECT:
3919 case HOST:
3920 case PRINT:
3921 case QUIT:
3922 case REMARK:
3923 case UNDEFINE:
3924 case VARIABLE:
3925 case WHENEVER:
3926 case ATTACH:
3927 case CAST:
3928 case TREAT:
3929 case TRIM:
3930 case LEFT:
3931 case RIGHT:
3932 case BOTH:
3933 case EMPTY:
3934 case MULTISET:
3935 case SUBMULTISET:
3936 case LEADING:
3937 case TRAILING:
3938 case CHAR_CS:
3939 case NCHAR_CS:
3940 case DBTIMEZONE:
3941 case SESSIONTIMEZONE:
3942 case AUTHENTICATED:
3943 case LINK:
3944 case SHARED:
3945 case DIRECTORY:
3946 case USER:
3947 case IDENTIFIER:
3948 case QUOTED_LITERAL:
3949 case SQLDATA_CLASS:
3950 case CUSTOMDATUM_CLASS:
3951 case ORADATA_CLASS:
3952 case JAVA_INTERFACE_CLASS:
3953 DeclarativeUnit();
3954 break;
3955 case CC_ERROR:
3956 jj_consume_token(CC_ERROR);
3957 Expression();
3958 jj_consume_token(CC_END);
3959 break;
3960 default:
3961 jj_la1[38] = jj_gen;
3962 jj_consume_token(-1);
3963 throw new ParseException();
3964 }
3965 }
3966 }
3967 label_11:
3968 while (true) {
3969 switch (jj_nt.kind) {
3970 case CC_ELSE:
3971 ;
3972 break;
3973 default:
3974 jj_la1[39] = jj_gen;
3975 break label_11;
3976 }
3977 jj_consume_token(CC_ELSE);
3978 label_12:
3979 while (true) {
3980 switch (jj_nt.kind) {
3981 case REPLACE:
3982 case DEFINER:
3983 case CURRENT_USER:
3984 case SERIALLY_REUSABLE:
3985 case RESTRICT_REFERENCES:
3986 case EXCEPTION_INIT:
3987 case AUTONOMOUS_TRANSACTION:
3988 case LANGUAGE:
3989 case INLINE:
3990 case ADD:
3991 case AGGREGATE:
3992 case ALL:
3993 case ALTER:
3994 case AND:
3995 case ANY:
3996 case ARRAY:
3997 case AS:
3998 case ASC:
3999 case AT:
4000 case ATTRIBUTE:
4001 case AUTHID:
4002 case AVG:
4003 case BETWEEN:
4004 case BINARY_INTEGER:
4005 case BODY:
4006 case BOOLEAN:
4007 case BULK:
4008 case BY:
4009 case BYTE:
4010 case CASCADE:
4011 case CASE:
4012 case CHAR:
4013 case CHAR_BASE:
4014 case CHECK:
4015 case CLOSE:
4016 case CLUSTER:
4017 case COALESCE:
4018 case COLLECT:
4019 case COLUMN:
4020 case COMMENT:
4021 case COMMIT:
4022 case COMPRESS:
4023 case CONNECT:
4024 case CONSTANT:
4025 case CONSTRUCTOR:
4026 case CONTINUE:
4027 case CONVERT:
4028 case CREATE:
4029 case CURRENT:
4030 case CURRVAL:
4031 case CURSOR:
4032 case DATA:
4033 case DATE:
4034 case DAY:
4035 case DECLARE:
4036 case DECIMAL:
4037 case _DEFAULT:
4038 case DELETE:
4039 case DESC:
4040 case DISABLE:
4041 case DISTINCT:
4042 case DO:
4043 case DROP:
4044 case EDITIONABLE:
4045 case ELEMENT:
4046 case ELSE:
4047 case ELSIF:
4048 case ENABLE:
4049 case ESCAPE:
4050 case EXCEPT:
4051 case EXCEPTION:
4052 case EXCEPTIONS:
4053 case EXCLUSIVE:
4054 case EXECUTE:
4055 case EXISTS:
4056 case EXIT:
4057 case EXTERNAL:
4058 case EXTENDS:
4059 case EXTRACT:
4060 case FALSE:
4061 case FETCH:
4062 case FINAL:
4063 case FLOAT:
4064 case FOR:
4065 case FORALL:
4066 case FORCE:
4067 case FROM:
4068 case FUNCTION:
4069 case GLOBAL:
4070 case GOTO:
4071 case GROUP:
4072 case HASH:
4073 case HAVING:
4074 case HEAP:
4075 case HOUR:
4076 case IF:
4077 case IMMEDIATE:
4078 case IN:
4079 case INDEX:
4080 case INDICES:
4081 case INDEXTYPE:
4082 case INDICATOR:
4083 case INSERT:
4084 case INSTANTIABLE:
4085 case INTEGER:
4086 case INTERFACE:
4087 case INTERSECT:
4088 case INTERVAL:
4089 case INTO:
4090 case INVALIDATE:
4091 case IS:
4092 case ISOLATION:
4093 case JAVA:
4094 case LEVEL:
4095 case LIKE:
4096 case LIMIT:
4097 case LIMITED:
4098 case LOCK:
4099 case LONG:
4100 case LOOP:
4101 case MAP:
4102 case MAX:
4103 case MEMBER:
4104 case MERGE:
4105 case MIN:
4106 case MINUS:
4107 case MINUTE:
4108 case MLSLABEL:
4109 case MODIFY:
4110 case MOD:
4111 case MODE:
4112 case MONTH:
4113 case NATURAL:
4114 case NATURALN:
4115 case NEW:
4116 case NEXTVAL:
4117 case NO:
4118 case NOCOPY:
4119 case NONEDITIONABLE:
4120 case NOT:
4121 case NOWAIT:
4122 case NULL:
4123 case NULLIF:
4124 case NUMBER:
4125 case BFILE_BASE:
4126 case BLOB_BASE:
4127 case CLOB_BASE:
4128 case DATE_BASE:
4129 case NUMBER_BASE:
4130 case OBJECT:
4131 case OCIROWID:
4132 case OF:
4133 case OID:
4134 case ON:
4135 case OPAQUE:
4136 case OPEN:
4137 case OPERATOR:
4138 case OPTION:
4139 case OR:
4140 case ORDER:
4141 case ORGANIZATION:
4142 case OTHERS:
4143 case OUT:
4144 case OVERRIDING:
4145 case PACKAGE:
4146 case PARTITION:
4147 case PCTFREE:
4148 case PLS_INTEGER:
4149 case POSITIVE:
4150 case POSITIVEN:
4151 case PRAGMA:
4152 case PRESERVE:
4153 case PRIOR:
4154 case PROMPT:
4155 case PRIVATE:
4156 case PROCEDURE:
4157 case PUBLIC:
4158 case RAISE:
4159 case RANGE:
4160 case RAW:
4161 case REAL:
4162 case RECORD:
4163 case REF:
4164 case RELEASE:
4165 case RELIES_ON:
4166 case RENAME:
4167 case RESULT:
4168 case RETURN:
4169 case RETURNING:
4170 case REVERSE:
4171 case ROLLBACK:
4172 case ROW:
4173 case ROWS:
4174 case ROWID:
4175 case ROWNUM:
4176 case ROWTYPE:
4177 case SAVE:
4178 case SAVEPOINT:
4179 case SECOND:
4180 case SELECT:
4181 case SELF:
4182 case SEPARATE:
4183 case SET:
4184 case SHARE:
4185 case SMALLINT:
4186 case SPACE:
4187 case SQL:
4188 case SQLCODE:
4189 case SQLERRM:
4190 case START:
4191 case STATIC:
4192 case STDDEV:
4193 case SUBTYPE:
4194 case SUBSTITUTABLE:
4195 case SUCCESSFUL:
4196 case SUM:
4197 case SYNONYM:
4198 case SYSDATE:
4199 case SYS_REFCURSOR:
4200 case TABLE:
4201 case TEMPORARY:
4202 case THEN:
4203 case TIME:
4204 case TIMESTAMP:
4205 case TIMEZONE_REGION:
4206 case TIMEZONE_ABBR:
4207 case TIMEZONE_MINUTE:
4208 case TIMEZONE_HOUR:
4209 case TO:
4210 case TRANSACTION:
4211 case TRIGGER:
4212 case TRUE:
4213 case TYPE:
4214 case UI:
4215 case UNDER:
4216 case USING:
4217 case WHILE:
4218 case YES:
4219 case SHOW:
4220 case A:
4221 case UPDATE:
4222 case VARCHAR:
4223 case VARCHAR2:
4224 case DOUBLE:
4225 case DEC:
4226 case PRECISION:
4227 case INT:
4228 case NUMERIC:
4229 case SIGNTYPE:
4230 case NCHAR:
4231 case NVARCHAR2:
4232 case STRING:
4233 case UROWID:
4234 case VARRAY:
4235 case VARYING:
4236 case BFILE:
4237 case BLOB:
4238 case CLOB:
4239 case NCLOB:
4240 case YEAR:
4241 case LOCAL:
4242 case WITH:
4243 case ZONE:
4244 case CHARACTER:
4245 case AFTER:
4246 case BEFORE:
4247 case OLD:
4248 case PARENT:
4249 case CC_IF:
4250 case CC_ERROR:
4251 case ANALYZE:
4252 case ASSOCIATE:
4253 case AUDIT:
4254 case COMPOUND:
4255 case DATABASE:
4256 case CALL:
4257 case DDL:
4258 case DISASSOCIATE:
4259 case EACH:
4260 case FOLLOWS:
4261 case LOGOFF:
4262 case LOGON:
4263 case NESTED:
4264 case NOAUDIT:
4265 case SCHEMA:
4266 case SERVERERROR:
4267 case SHUTDOWN:
4268 case STARTUP:
4269 case STATEMENT:
4270 case STATISTICS:
4271 case SUSPEND:
4272 case TRUNCATE:
4273 case WRAPPED:
4274 case LIBRARY:
4275 case NAME:
4276 case STRUCT:
4277 case CONTEXT:
4278 case PARAMETERS:
4279 case LENGTH:
4280 case TDO:
4281 case MAXLEN:
4282 case CHARSETID:
4283 case CHARSETFORM:
4284 case ACCEPT:
4285 case ACCESSIBLE:
4286 case COPY:
4287 case DEFINE:
4288 case DISCONNECT:
4289 case HOST:
4290 case PRINT:
4291 case QUIT:
4292 case REMARK:
4293 case UNDEFINE:
4294 case VARIABLE:
4295 case WHENEVER:
4296 case ATTACH:
4297 case CAST:
4298 case TREAT:
4299 case TRIM:
4300 case LEFT:
4301 case RIGHT:
4302 case BOTH:
4303 case EMPTY:
4304 case MULTISET:
4305 case SUBMULTISET:
4306 case LEADING:
4307 case TRAILING:
4308 case CHAR_CS:
4309 case NCHAR_CS:
4310 case DBTIMEZONE:
4311 case SESSIONTIMEZONE:
4312 case AUTHENTICATED:
4313 case LINK:
4314 case SHARED:
4315 case DIRECTORY:
4316 case USER:
4317 case IDENTIFIER:
4318 case QUOTED_LITERAL:
4319 case SQLDATA_CLASS:
4320 case CUSTOMDATUM_CLASS:
4321 case ORADATA_CLASS:
4322 case JAVA_INTERFACE_CLASS:
4323 ;
4324 break;
4325 default:
4326 jj_la1[40] = jj_gen;
4327 break label_12;
4328 }
4329 switch (jj_nt.kind) {
4330 case REPLACE:
4331 case DEFINER:
4332 case CURRENT_USER:
4333 case SERIALLY_REUSABLE:
4334 case RESTRICT_REFERENCES:
4335 case EXCEPTION_INIT:
4336 case AUTONOMOUS_TRANSACTION:
4337 case LANGUAGE:
4338 case INLINE:
4339 case ADD:
4340 case AGGREGATE:
4341 case ALL:
4342 case ALTER:
4343 case AND:
4344 case ANY:
4345 case ARRAY:
4346 case AS:
4347 case ASC:
4348 case AT:
4349 case ATTRIBUTE:
4350 case AUTHID:
4351 case AVG:
4352 case BETWEEN:
4353 case BINARY_INTEGER:
4354 case BODY:
4355 case BOOLEAN:
4356 case BULK:
4357 case BY:
4358 case BYTE:
4359 case CASCADE:
4360 case CASE:
4361 case CHAR:
4362 case CHAR_BASE:
4363 case CHECK:
4364 case CLOSE:
4365 case CLUSTER:
4366 case COALESCE:
4367 case COLLECT:
4368 case COLUMN:
4369 case COMMENT:
4370 case COMMIT:
4371 case COMPRESS:
4372 case CONNECT:
4373 case CONSTANT:
4374 case CONSTRUCTOR:
4375 case CONTINUE:
4376 case CONVERT:
4377 case CREATE:
4378 case CURRENT:
4379 case CURRVAL:
4380 case CURSOR:
4381 case DATA:
4382 case DATE:
4383 case DAY:
4384 case DECLARE:
4385 case DECIMAL:
4386 case _DEFAULT:
4387 case DELETE:
4388 case DESC:
4389 case DISABLE:
4390 case DISTINCT:
4391 case DO:
4392 case DROP:
4393 case EDITIONABLE:
4394 case ELEMENT:
4395 case ELSE:
4396 case ELSIF:
4397 case ENABLE:
4398 case ESCAPE:
4399 case EXCEPT:
4400 case EXCEPTION:
4401 case EXCEPTIONS:
4402 case EXCLUSIVE:
4403 case EXECUTE:
4404 case EXISTS:
4405 case EXIT:
4406 case EXTERNAL:
4407 case EXTENDS:
4408 case EXTRACT:
4409 case FALSE:
4410 case FETCH:
4411 case FINAL:
4412 case FLOAT:
4413 case FOR:
4414 case FORALL:
4415 case FORCE:
4416 case FROM:
4417 case FUNCTION:
4418 case GLOBAL:
4419 case GOTO:
4420 case GROUP:
4421 case HASH:
4422 case HAVING:
4423 case HEAP:
4424 case HOUR:
4425 case IF:
4426 case IMMEDIATE:
4427 case IN:
4428 case INDEX:
4429 case INDICES:
4430 case INDEXTYPE:
4431 case INDICATOR:
4432 case INSERT:
4433 case INSTANTIABLE:
4434 case INTEGER:
4435 case INTERFACE:
4436 case INTERSECT:
4437 case INTERVAL:
4438 case INTO:
4439 case INVALIDATE:
4440 case IS:
4441 case ISOLATION:
4442 case JAVA:
4443 case LEVEL:
4444 case LIKE:
4445 case LIMIT:
4446 case LIMITED:
4447 case LOCK:
4448 case LONG:
4449 case LOOP:
4450 case MAP:
4451 case MAX:
4452 case MEMBER:
4453 case MERGE:
4454 case MIN:
4455 case MINUS:
4456 case MINUTE:
4457 case MLSLABEL:
4458 case MODIFY:
4459 case MOD:
4460 case MODE:
4461 case MONTH:
4462 case NATURAL:
4463 case NATURALN:
4464 case NEW:
4465 case NEXTVAL:
4466 case NO:
4467 case NOCOPY:
4468 case NONEDITIONABLE:
4469 case NOT:
4470 case NOWAIT:
4471 case NULL:
4472 case NULLIF:
4473 case NUMBER:
4474 case BFILE_BASE:
4475 case BLOB_BASE:
4476 case CLOB_BASE:
4477 case DATE_BASE:
4478 case NUMBER_BASE:
4479 case OBJECT:
4480 case OCIROWID:
4481 case OF:
4482 case OID:
4483 case ON:
4484 case OPAQUE:
4485 case OPEN:
4486 case OPERATOR:
4487 case OPTION:
4488 case OR:
4489 case ORDER:
4490 case ORGANIZATION:
4491 case OTHERS:
4492 case OUT:
4493 case OVERRIDING:
4494 case PACKAGE:
4495 case PARTITION:
4496 case PCTFREE:
4497 case PLS_INTEGER:
4498 case POSITIVE:
4499 case POSITIVEN:
4500 case PRAGMA:
4501 case PRESERVE:
4502 case PRIOR:
4503 case PROMPT:
4504 case PRIVATE:
4505 case PROCEDURE:
4506 case PUBLIC:
4507 case RAISE:
4508 case RANGE:
4509 case RAW:
4510 case REAL:
4511 case RECORD:
4512 case REF:
4513 case RELEASE:
4514 case RELIES_ON:
4515 case RENAME:
4516 case RESULT:
4517 case RETURN:
4518 case RETURNING:
4519 case REVERSE:
4520 case ROLLBACK:
4521 case ROW:
4522 case ROWS:
4523 case ROWID:
4524 case ROWNUM:
4525 case ROWTYPE:
4526 case SAVE:
4527 case SAVEPOINT:
4528 case SECOND:
4529 case SELECT:
4530 case SELF:
4531 case SEPARATE:
4532 case SET:
4533 case SHARE:
4534 case SMALLINT:
4535 case SPACE:
4536 case SQL:
4537 case SQLCODE:
4538 case SQLERRM:
4539 case START:
4540 case STATIC:
4541 case STDDEV:
4542 case SUBTYPE:
4543 case SUBSTITUTABLE:
4544 case SUCCESSFUL:
4545 case SUM:
4546 case SYNONYM:
4547 case SYSDATE:
4548 case SYS_REFCURSOR:
4549 case TABLE:
4550 case TEMPORARY:
4551 case THEN:
4552 case TIME:
4553 case TIMESTAMP:
4554 case TIMEZONE_REGION:
4555 case TIMEZONE_ABBR:
4556 case TIMEZONE_MINUTE:
4557 case TIMEZONE_HOUR:
4558 case TO:
4559 case TRANSACTION:
4560 case TRIGGER:
4561 case TRUE:
4562 case TYPE:
4563 case UI:
4564 case UNDER:
4565 case USING:
4566 case WHILE:
4567 case YES:
4568 case SHOW:
4569 case A:
4570 case UPDATE:
4571 case VARCHAR:
4572 case VARCHAR2:
4573 case DOUBLE:
4574 case DEC:
4575 case PRECISION:
4576 case INT:
4577 case NUMERIC:
4578 case SIGNTYPE:
4579 case NCHAR:
4580 case NVARCHAR2:
4581 case STRING:
4582 case UROWID:
4583 case VARRAY:
4584 case VARYING:
4585 case BFILE:
4586 case BLOB:
4587 case CLOB:
4588 case NCLOB:
4589 case YEAR:
4590 case LOCAL:
4591 case WITH:
4592 case ZONE:
4593 case CHARACTER:
4594 case AFTER:
4595 case BEFORE:
4596 case OLD:
4597 case PARENT:
4598 case CC_IF:
4599 case ANALYZE:
4600 case ASSOCIATE:
4601 case AUDIT:
4602 case COMPOUND:
4603 case DATABASE:
4604 case CALL:
4605 case DDL:
4606 case DISASSOCIATE:
4607 case EACH:
4608 case FOLLOWS:
4609 case LOGOFF:
4610 case LOGON:
4611 case NESTED:
4612 case NOAUDIT:
4613 case SCHEMA:
4614 case SERVERERROR:
4615 case SHUTDOWN:
4616 case STARTUP:
4617 case STATEMENT:
4618 case STATISTICS:
4619 case SUSPEND:
4620 case TRUNCATE:
4621 case WRAPPED:
4622 case LIBRARY:
4623 case NAME:
4624 case STRUCT:
4625 case CONTEXT:
4626 case PARAMETERS:
4627 case LENGTH:
4628 case TDO:
4629 case MAXLEN:
4630 case CHARSETID:
4631 case CHARSETFORM:
4632 case ACCEPT:
4633 case ACCESSIBLE:
4634 case COPY:
4635 case DEFINE:
4636 case DISCONNECT:
4637 case HOST:
4638 case PRINT:
4639 case QUIT:
4640 case REMARK:
4641 case UNDEFINE:
4642 case VARIABLE:
4643 case WHENEVER:
4644 case ATTACH:
4645 case CAST:
4646 case TREAT:
4647 case TRIM:
4648 case LEFT:
4649 case RIGHT:
4650 case BOTH:
4651 case EMPTY:
4652 case MULTISET:
4653 case SUBMULTISET:
4654 case LEADING:
4655 case TRAILING:
4656 case CHAR_CS:
4657 case NCHAR_CS:
4658 case DBTIMEZONE:
4659 case SESSIONTIMEZONE:
4660 case AUTHENTICATED:
4661 case LINK:
4662 case SHARED:
4663 case DIRECTORY:
4664 case USER:
4665 case IDENTIFIER:
4666 case QUOTED_LITERAL:
4667 case SQLDATA_CLASS:
4668 case CUSTOMDATUM_CLASS:
4669 case ORADATA_CLASS:
4670 case JAVA_INTERFACE_CLASS:
4671 DeclarativeUnit();
4672 break;
4673 case CC_ERROR:
4674 jj_consume_token(CC_ERROR);
4675 Expression();
4676 jj_consume_token(CC_END);
4677 break;
4678 default:
4679 jj_la1[41] = jj_gen;
4680 jj_consume_token(-1);
4681 throw new ParseException();
4682 }
4683 }
4684 }
4685 jj_consume_token(CC_END);
4686 jjtree.closeNodeScope(jjtn000, true);
4687 jjtc000 = false;
4688 {if (true) return jjtn000 ;}
4689 } catch (Throwable jjte000) {
4690 if (jjtc000) {
4691 jjtree.clearNodeScope(jjtn000);
4692 jjtc000 = false;
4693 } else {
4694 jjtree.popNode();
4695 }
4696 if (jjte000 instanceof RuntimeException) {
4697 {if (true) throw (RuntimeException)jjte000;}
4698 }
4699 if (jjte000 instanceof ParseException) {
4700 {if (true) throw (ParseException)jjte000;}
4701 }
4702 {if (true) throw (Error)jjte000;}
4703 } finally {
4704 if (jjtc000) {
4705 jjtree.closeNodeScope(jjtn000, true);
4706 }
4707 }
4708 throw new Error("Missing return statement in function");
4709 }
4710
4711
4712
4713
4714
4715
4716
4717 final public ASTProgramUnit ProgramUnit() throws ParseException {
4718
4719 ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720 boolean jjtc000 = true;
4721 jjtree.openNodeScope(jjtn000);
4722 try {
4723 switch (jj_nt.kind) {
4724 case CREATE:
4725 jj_consume_token(CREATE);
4726 switch (jj_nt.kind) {
4727 case OR:
4728 jj_consume_token(OR);
4729 jj_consume_token(REPLACE);
4730 break;
4731 default:
4732 jj_la1[42] = jj_gen;
4733 ;
4734 }
4735 switch (jj_nt.kind) {
4736 case EDITIONABLE:
4737 case NONEDITIONABLE:
4738 switch (jj_nt.kind) {
4739 case EDITIONABLE:
4740 jj_consume_token(EDITIONABLE);
4741 break;
4742 case NONEDITIONABLE:
4743 jj_consume_token(NONEDITIONABLE);
4744 break;
4745 default:
4746 jj_la1[43] = jj_gen;
4747 jj_consume_token(-1);
4748 throw new ParseException();
4749 }
4750 break;
4751 default:
4752 jj_la1[44] = jj_gen;
4753 ;
4754 }
4755 break;
4756 default:
4757 jj_la1[45] = jj_gen;
4758 ;
4759 }
4760 MethodDeclarator();
4761 switch (jj_nt.kind) {
4762 case WRAPPED:
4763 WrappedObject();
4764 break;
4765 case 4:
4766 case AGGREGATE:
4767 case AS:
4768 case AUTHID:
4769 case DETERMINISTIC:
4770 case IS:
4771 case PARALLEL_ENABLE:
4772 case PIPELINED:
4773 case RESULT_CACHE:
4774 case ACCESSIBLE:
4775 label_13:
4776 while (true) {
4777 switch (jj_nt.kind) {
4778 case AUTHID:
4779 case DETERMINISTIC:
4780 case PARALLEL_ENABLE:
4781 case PIPELINED:
4782 case RESULT_CACHE:
4783 case ACCESSIBLE:
4784 ;
4785 break;
4786 default:
4787 jj_la1[46] = jj_gen;
4788 break label_13;
4789 }
4790 switch (jj_nt.kind) {
4791 case AUTHID:
4792 jj_consume_token(AUTHID);
4793 switch (jj_nt.kind) {
4794 case CURRENT_USER:
4795 jj_consume_token(CURRENT_USER);
4796 break;
4797 case DEFINER:
4798 jj_consume_token(DEFINER);
4799 break;
4800 default:
4801 jj_la1[47] = jj_gen;
4802 jj_consume_token(-1);
4803 throw new ParseException();
4804 }
4805 break;
4806 case DETERMINISTIC:
4807 jj_consume_token(DETERMINISTIC);
4808 break;
4809 case ACCESSIBLE:
4810 AccessibleByClause();
4811 break;
4812 case PARALLEL_ENABLE:
4813 jj_consume_token(PARALLEL_ENABLE);
4814 switch (jj_nt.kind) {
4815 case 5:
4816 ParallelClause();
4817 break;
4818 default:
4819 jj_la1[48] = jj_gen;
4820 ;
4821 }
4822 switch (jj_nt.kind) {
4823 case USING:
4824 jj_consume_token(USING);
4825 ID();
4826 switch (jj_nt.kind) {
4827 case 3:
4828 jj_consume_token(3);
4829 ID();
4830 break;
4831 default:
4832 jj_la1[49] = jj_gen;
4833 ;
4834 }
4835 break;
4836 default:
4837 jj_la1[50] = jj_gen;
4838 ;
4839 }
4840 break;
4841 case PIPELINED:
4842 jj_consume_token(PIPELINED);
4843 switch (jj_nt.kind) {
4844 case CLUSTER:
4845 case ORDER:
4846 case USING:
4847 switch (jj_nt.kind) {
4848 case USING:
4849 jj_consume_token(USING);
4850 ID();
4851 switch (jj_nt.kind) {
4852 case 3:
4853 jj_consume_token(3);
4854 ID();
4855 break;
4856 default:
4857 jj_la1[51] = jj_gen;
4858 ;
4859 }
4860 break;
4861 case CLUSTER:
4862 case ORDER:
4863 switch (jj_nt.kind) {
4864 case ORDER:
4865 jj_consume_token(ORDER);
4866 break;
4867 case CLUSTER:
4868 jj_consume_token(CLUSTER);
4869 break;
4870 default:
4871 jj_la1[52] = jj_gen;
4872 jj_consume_token(-1);
4873 throw new ParseException();
4874 }
4875 switch (jj_nt.kind) {
4876 case REPLACE:
4877 case DEFINER:
4878 case CURRENT_USER:
4879 case SERIALLY_REUSABLE:
4880 case RESTRICT_REFERENCES:
4881 case EXCEPTION_INIT:
4882 case AUTONOMOUS_TRANSACTION:
4883 case LANGUAGE:
4884 case INLINE:
4885 case ADD:
4886 case AGGREGATE:
4887 case ALL:
4888 case ALTER:
4889 case AND:
4890 case ANY:
4891 case ARRAY:
4892 case AS:
4893 case ASC:
4894 case AT:
4895 case ATTRIBUTE:
4896 case AUTHID:
4897 case AVG:
4898 case BETWEEN:
4899 case BINARY_INTEGER:
4900 case BODY:
4901 case BOOLEAN:
4902 case BULK:
4903 case BY:
4904 case BYTE:
4905 case CASCADE:
4906 case CASE:
4907 case CHAR:
4908 case CHAR_BASE:
4909 case CHECK:
4910 case CLOSE:
4911 case CLUSTER:
4912 case COALESCE:
4913 case COLLECT:
4914 case COLUMN:
4915 case COMMENT:
4916 case COMMIT:
4917 case COMPRESS:
4918 case CONNECT:
4919 case CONSTANT:
4920 case CONSTRUCTOR:
4921 case CONTINUE:
4922 case CONVERT:
4923 case CREATE:
4924 case CURRENT:
4925 case CURRVAL:
4926 case CURSOR:
4927 case DATA:
4928 case DATE:
4929 case DAY:
4930 case DECLARE:
4931 case DECIMAL:
4932 case _DEFAULT:
4933 case DELETE:
4934 case DESC:
4935 case DISABLE:
4936 case DISTINCT:
4937 case DO:
4938 case DROP:
4939 case EDITIONABLE:
4940 case ELEMENT:
4941 case ELSE:
4942 case ELSIF:
4943 case ENABLE:
4944 case ESCAPE:
4945 case EXCEPT:
4946 case EXCEPTION:
4947 case EXCEPTIONS:
4948 case EXCLUSIVE:
4949 case EXECUTE:
4950 case EXISTS:
4951 case EXIT:
4952 case EXTERNAL:
4953 case EXTENDS:
4954 case EXTRACT:
4955 case FALSE:
4956 case FETCH:
4957 case FINAL:
4958 case FLOAT:
4959 case FOR:
4960 case FORALL:
4961 case FORCE:
4962 case FROM:
4963 case FUNCTION:
4964 case GLOBAL:
4965 case GOTO:
4966 case GROUP:
4967 case HASH:
4968 case HAVING:
4969 case HEAP:
4970 case HOUR:
4971 case IF:
4972 case IMMEDIATE:
4973 case IN:
4974 case INDEX:
4975 case INDICES:
4976 case INDEXTYPE:
4977 case INDICATOR:
4978 case INSERT:
4979 case INSTANTIABLE:
4980 case INTEGER:
4981 case INTERFACE:
4982 case INTERSECT:
4983 case INTERVAL:
4984 case INTO:
4985 case INVALIDATE:
4986 case IS:
4987 case ISOLATION:
4988 case JAVA:
4989 case LEVEL:
4990 case LIKE:
4991 case LIMIT:
4992 case LIMITED:
4993 case LOCK:
4994 case LONG:
4995 case LOOP:
4996 case MAP:
4997 case MAX:
4998 case MEMBER:
4999 case MERGE:
5000 case MIN:
5001 case MINUS:
5002 case MINUTE:
5003 case MLSLABEL:
5004 case MODIFY:
5005 case MOD:
5006 case MODE:
5007 case MONTH:
5008 case NATURAL:
5009 case NATURALN:
5010 case NEW:
5011 case NEXTVAL:
5012 case NO:
5013 case NOCOPY:
5014 case NONEDITIONABLE:
5015 case NOT:
5016 case NOWAIT:
5017 case NULL:
5018 case NULLIF:
5019 case NUMBER:
5020 case BFILE_BASE:
5021 case BLOB_BASE:
5022 case CLOB_BASE:
5023 case DATE_BASE:
5024 case NUMBER_BASE:
5025 case OBJECT:
5026 case OCIROWID:
5027 case OF:
5028 case OID:
5029 case ON:
5030 case OPAQUE:
5031 case OPEN:
5032 case OPERATOR:
5033 case OPTION:
5034 case OR:
5035 case ORDER:
5036 case ORGANIZATION:
5037 case OTHERS:
5038 case OUT:
5039 case OVERRIDING:
5040 case PACKAGE:
5041 case PARTITION:
5042 case PCTFREE:
5043 case PLS_INTEGER:
5044 case POSITIVE:
5045 case POSITIVEN:
5046 case PRESERVE:
5047 case PRIOR:
5048 case PROMPT:
5049 case PRIVATE:
5050 case PROCEDURE:
5051 case PUBLIC:
5052 case RAISE:
5053 case RANGE:
5054 case RAW:
5055 case REAL:
5056 case RECORD:
5057 case REF:
5058 case RELEASE:
5059 case RELIES_ON:
5060 case RENAME:
5061 case RESULT:
5062 case RETURN:
5063 case RETURNING:
5064 case REVERSE:
5065 case ROLLBACK:
5066 case ROW:
5067 case ROWS:
5068 case ROWID:
5069 case ROWNUM:
5070 case ROWTYPE:
5071 case SAVE:
5072 case SAVEPOINT:
5073 case SECOND:
5074 case SELECT:
5075 case SELF:
5076 case SEPARATE:
5077 case SET:
5078 case SHARE:
5079 case SMALLINT:
5080 case SPACE:
5081 case SQL:
5082 case SQLCODE:
5083 case SQLERRM:
5084 case START:
5085 case STATIC:
5086 case STDDEV:
5087 case SUBTYPE:
5088 case SUBSTITUTABLE:
5089 case SUCCESSFUL:
5090 case SUM:
5091 case SYNONYM:
5092 case SYSDATE:
5093 case SYS_REFCURSOR:
5094 case TABLE:
5095 case TEMPORARY:
5096 case THEN:
5097 case TIME:
5098 case TIMESTAMP:
5099 case TIMEZONE_REGION:
5100 case TIMEZONE_ABBR:
5101 case TIMEZONE_MINUTE:
5102 case TIMEZONE_HOUR:
5103 case TO:
5104 case TRANSACTION:
5105 case TRIGGER:
5106 case TRUE:
5107 case TYPE:
5108 case UI:
5109 case UNDER:
5110 case USING:
5111 case WHILE:
5112 case YES:
5113 case SHOW:
5114 case A:
5115 case UPDATE:
5116 case VARCHAR:
5117 case VARCHAR2:
5118 case DOUBLE:
5119 case DEC:
5120 case PRECISION:
5121 case INT:
5122 case NUMERIC:
5123 case SIGNTYPE:
5124 case NCHAR:
5125 case NVARCHAR2:
5126 case STRING:
5127 case UROWID:
5128 case VARRAY:
5129 case VARYING:
5130 case BFILE:
5131 case BLOB:
5132 case CLOB:
5133 case NCLOB:
5134 case YEAR:
5135 case LOCAL:
5136 case WITH:
5137 case ZONE:
5138 case CHARACTER:
5139 case AFTER:
5140 case BEFORE:
5141 case OLD:
5142 case PARENT:
5143 case ANALYZE:
5144 case ASSOCIATE:
5145 case AUDIT:
5146 case COMPOUND:
5147 case DATABASE:
5148 case CALL:
5149 case DDL:
5150 case DISASSOCIATE:
5151 case EACH:
5152 case FOLLOWS:
5153 case LOGOFF:
5154 case LOGON:
5155 case NESTED:
5156 case NOAUDIT:
5157 case SCHEMA:
5158 case SERVERERROR:
5159 case SHUTDOWN:
5160 case STARTUP:
5161 case STATEMENT:
5162 case STATISTICS:
5163 case SUSPEND:
5164 case TRUNCATE:
5165 case WRAPPED:
5166 case LIBRARY:
5167 case NAME:
5168 case STRUCT:
5169 case CONTEXT:
5170 case PARAMETERS:
5171 case LENGTH:
5172 case TDO:
5173 case MAXLEN:
5174 case CHARSETID:
5175 case CHARSETFORM:
5176 case ACCEPT:
5177 case ACCESSIBLE:
5178 case COPY:
5179 case DEFINE:
5180 case DISCONNECT:
5181 case HOST:
5182 case PRINT:
5183 case QUIT:
5184 case REMARK:
5185 case UNDEFINE:
5186 case VARIABLE:
5187 case WHENEVER:
5188 case ATTACH:
5189 case CAST:
5190 case TREAT:
5191 case TRIM:
5192 case LEFT:
5193 case RIGHT:
5194 case BOTH:
5195 case EMPTY:
5196 case MULTISET:
5197 case SUBMULTISET:
5198 case LEADING:
5199 case TRAILING:
5200 case CHAR_CS:
5201 case NCHAR_CS:
5202 case DBTIMEZONE:
5203 case SESSIONTIMEZONE:
5204 case AUTHENTICATED:
5205 case LINK:
5206 case SHARED:
5207 case DIRECTORY:
5208 case USER:
5209 case IDENTIFIER:
5210 case QUOTED_LITERAL:
5211 case SQLDATA_CLASS:
5212 case CUSTOMDATUM_CLASS:
5213 case ORADATA_CLASS:
5214 case JAVA_INTERFACE_CLASS:
5215 ID();
5216 break;
5217 default:
5218 jj_la1[53] = jj_gen;
5219 ;
5220 }
5221 jj_consume_token(BY);
5222 jj_consume_token(5);
5223 ID();
5224 label_14:
5225 while (true) {
5226 switch (jj_nt.kind) {
5227 case 6:
5228 ;
5229 break;
5230 default:
5231 jj_la1[54] = jj_gen;
5232 break label_14;
5233 }
5234 jj_consume_token(6);
5235 ID();
5236 }
5237 jj_consume_token(7);
5238 break;
5239 default:
5240 jj_la1[55] = jj_gen;
5241 jj_consume_token(-1);
5242 throw new ParseException();
5243 }
5244 break;
5245 default:
5246 jj_la1[56] = jj_gen;
5247 ;
5248 }
5249 break;
5250 case RESULT_CACHE:
5251 jj_consume_token(RESULT_CACHE);
5252 switch (jj_nt.kind) {
5253 case RELIES_ON:
5254 jj_consume_token(RELIES_ON);
5255 jj_consume_token(5);
5256 ID();
5257 switch (jj_nt.kind) {
5258 case 3:
5259 jj_consume_token(3);
5260 ID();
5261 break;
5262 default:
5263 jj_la1[57] = jj_gen;
5264 ;
5265 }
5266 label_15:
5267 while (true) {
5268 switch (jj_nt.kind) {
5269 case 6:
5270 ;
5271 break;
5272 default:
5273 jj_la1[58] = jj_gen;
5274 break label_15;
5275 }
5276 jj_consume_token(6);
5277 ID();
5278 switch (jj_nt.kind) {
5279 case 3:
5280 jj_consume_token(3);
5281 ID();
5282 break;
5283 default:
5284 jj_la1[59] = jj_gen;
5285 ;
5286 }
5287 }
5288 jj_consume_token(7);
5289 break;
5290 default:
5291 jj_la1[60] = jj_gen;
5292 ;
5293 }
5294 break;
5295 default:
5296 jj_la1[61] = jj_gen;
5297 jj_consume_token(-1);
5298 throw new ParseException();
5299 }
5300 }
5301 switch (jj_nt.kind) {
5302 case AGGREGATE:
5303 jj_consume_token(AGGREGATE);
5304 jj_consume_token(USING);
5305 ID();
5306 break;
5307 default:
5308 jj_la1[62] = jj_gen;
5309 ;
5310 }
5311 switch (jj_nt.kind) {
5312 case AS:
5313 case IS:
5314 switch (jj_nt.kind) {
5315 case IS:
5316 jj_consume_token(IS);
5317 break;
5318 case AS:
5319 jj_consume_token(AS);
5320 break;
5321 default:
5322 jj_la1[63] = jj_gen;
5323 jj_consume_token(-1);
5324 throw new ParseException();
5325 }
5326 if (jj_2_21(2)) {
5327 CallSpecTail();
5328 } else {
5329 switch (jj_nt.kind) {
5330 case REPLACE:
5331 case DEFINER:
5332 case CURRENT_USER:
5333 case SERIALLY_REUSABLE:
5334 case RESTRICT_REFERENCES:
5335 case EXCEPTION_INIT:
5336 case AUTONOMOUS_TRANSACTION:
5337 case LANGUAGE:
5338 case INLINE:
5339 case ADD:
5340 case AGGREGATE:
5341 case ALL:
5342 case ALTER:
5343 case AND:
5344 case ANY:
5345 case ARRAY:
5346 case AS:
5347 case ASC:
5348 case AT:
5349 case ATTRIBUTE:
5350 case AUTHID:
5351 case AVG:
5352 case BEGIN:
5353 case BETWEEN:
5354 case BINARY_INTEGER:
5355 case BODY:
5356 case BOOLEAN:
5357 case BULK:
5358 case BY:
5359 case BYTE:
5360 case CASCADE:
5361 case CASE:
5362 case CHAR:
5363 case CHAR_BASE:
5364 case CHECK:
5365 case CLOSE:
5366 case CLUSTER:
5367 case COALESCE:
5368 case COLLECT:
5369 case COLUMN:
5370 case COMMENT:
5371 case COMMIT:
5372 case COMPRESS:
5373 case CONNECT:
5374 case CONSTANT:
5375 case CONSTRUCTOR:
5376 case CONTINUE:
5377 case CONVERT:
5378 case CREATE:
5379 case CURRENT:
5380 case CURRVAL:
5381 case CURSOR:
5382 case DATA:
5383 case DATE:
5384 case DAY:
5385 case DECLARE:
5386 case DECIMAL:
5387 case _DEFAULT:
5388 case DELETE:
5389 case DESC:
5390 case DISABLE:
5391 case DISTINCT:
5392 case DO:
5393 case DROP:
5394 case EDITIONABLE:
5395 case ELEMENT:
5396 case ELSE:
5397 case ELSIF:
5398 case ENABLE:
5399 case ESCAPE:
5400 case EXCEPT:
5401 case EXCEPTION:
5402 case EXCEPTIONS:
5403 case EXCLUSIVE:
5404 case EXECUTE:
5405 case EXISTS:
5406 case EXIT:
5407 case EXTERNAL:
5408 case EXTENDS:
5409 case EXTRACT:
5410 case FALSE:
5411 case FETCH:
5412 case FINAL:
5413 case FLOAT:
5414 case FOR:
5415 case FORALL:
5416 case FORCE:
5417 case FROM:
5418 case FUNCTION:
5419 case GLOBAL:
5420 case GOTO:
5421 case GROUP:
5422 case HASH:
5423 case HAVING:
5424 case HEAP:
5425 case HOUR:
5426 case IF:
5427 case IMMEDIATE:
5428 case IN:
5429 case INDEX:
5430 case INDICES:
5431 case INDEXTYPE:
5432 case INDICATOR:
5433 case INSERT:
5434 case INSTANTIABLE:
5435 case INTEGER:
5436 case INTERFACE:
5437 case INTERSECT:
5438 case INTERVAL:
5439 case INTO:
5440 case INVALIDATE:
5441 case IS:
5442 case ISOLATION:
5443 case JAVA:
5444 case LEVEL:
5445 case LIKE:
5446 case LIMIT:
5447 case LIMITED:
5448 case LOCK:
5449 case LONG:
5450 case LOOP:
5451 case MAP:
5452 case MAX:
5453 case MEMBER:
5454 case MERGE:
5455 case MIN:
5456 case MINUS:
5457 case MINUTE:
5458 case MLSLABEL:
5459 case MODIFY:
5460 case MOD:
5461 case MODE:
5462 case MONTH:
5463 case NATURAL:
5464 case NATURALN:
5465 case NEW:
5466 case NEXTVAL:
5467 case NO:
5468 case NOCOPY:
5469 case NONEDITIONABLE:
5470 case NOT:
5471 case NOWAIT:
5472 case NULL:
5473 case NULLIF:
5474 case NUMBER:
5475 case BFILE_BASE:
5476 case BLOB_BASE:
5477 case CLOB_BASE:
5478 case DATE_BASE:
5479 case NUMBER_BASE:
5480 case OBJECT:
5481 case OCIROWID:
5482 case OF:
5483 case OID:
5484 case ON:
5485 case OPAQUE:
5486 case OPEN:
5487 case OPERATOR:
5488 case OPTION:
5489 case OR:
5490 case ORDER:
5491 case ORGANIZATION:
5492 case OTHERS:
5493 case OUT:
5494 case OVERRIDING:
5495 case PACKAGE:
5496 case PARTITION:
5497 case PCTFREE:
5498 case PLS_INTEGER:
5499 case POSITIVE:
5500 case POSITIVEN:
5501 case PRAGMA:
5502 case PRESERVE:
5503 case PRIOR:
5504 case PROMPT:
5505 case PRIVATE:
5506 case PROCEDURE:
5507 case PUBLIC:
5508 case RAISE:
5509 case RANGE:
5510 case RAW:
5511 case REAL:
5512 case RECORD:
5513 case REF:
5514 case RELEASE:
5515 case RELIES_ON:
5516 case RENAME:
5517 case RESULT:
5518 case RETURN:
5519 case RETURNING:
5520 case REVERSE:
5521 case ROLLBACK:
5522 case ROW:
5523 case ROWS:
5524 case ROWID:
5525 case ROWNUM:
5526 case ROWTYPE:
5527 case SAVE:
5528 case SAVEPOINT:
5529 case SECOND:
5530 case SELECT:
5531 case SELF:
5532 case SEPARATE:
5533 case SET:
5534 case SHARE:
5535 case SMALLINT:
5536 case SPACE:
5537 case SQL:
5538 case SQLCODE:
5539 case SQLERRM:
5540 case START:
5541 case STATIC:
5542 case STDDEV:
5543 case SUBTYPE:
5544 case SUBSTITUTABLE:
5545 case SUCCESSFUL:
5546 case SUM:
5547 case SYNONYM:
5548 case SYSDATE:
5549 case SYS_REFCURSOR:
5550 case TABLE:
5551 case TEMPORARY:
5552 case THEN:
5553 case TIME:
5554 case TIMESTAMP:
5555 case TIMEZONE_REGION:
5556 case TIMEZONE_ABBR:
5557 case TIMEZONE_MINUTE:
5558 case TIMEZONE_HOUR:
5559 case TO:
5560 case TRANSACTION:
5561 case TRIGGER:
5562 case TRUE:
5563 case TYPE:
5564 case UI:
5565 case UNDER:
5566 case USING:
5567 case WHILE:
5568 case YES:
5569 case SHOW:
5570 case A:
5571 case UPDATE:
5572 case VARCHAR:
5573 case VARCHAR2:
5574 case DOUBLE:
5575 case DEC:
5576 case PRECISION:
5577 case INT:
5578 case NUMERIC:
5579 case SIGNTYPE:
5580 case NCHAR:
5581 case NVARCHAR2:
5582 case STRING:
5583 case UROWID:
5584 case VARRAY:
5585 case VARYING:
5586 case BFILE:
5587 case BLOB:
5588 case CLOB:
5589 case NCLOB:
5590 case YEAR:
5591 case LOCAL:
5592 case WITH:
5593 case ZONE:
5594 case CHARACTER:
5595 case AFTER:
5596 case BEFORE:
5597 case OLD:
5598 case PARENT:
5599 case CC_IF:
5600 case ANALYZE:
5601 case ASSOCIATE:
5602 case AUDIT:
5603 case COMPOUND:
5604 case DATABASE:
5605 case CALL:
5606 case DDL:
5607 case DISASSOCIATE:
5608 case EACH:
5609 case FOLLOWS:
5610 case LOGOFF:
5611 case LOGON:
5612 case NESTED:
5613 case NOAUDIT:
5614 case SCHEMA:
5615 case SERVERERROR:
5616 case SHUTDOWN:
5617 case STARTUP:
5618 case STATEMENT:
5619 case STATISTICS:
5620 case SUSPEND:
5621 case TRUNCATE:
5622 case WRAPPED:
5623 case LIBRARY:
5624 case NAME:
5625 case STRUCT:
5626 case CONTEXT:
5627 case PARAMETERS:
5628 case LENGTH:
5629 case TDO:
5630 case MAXLEN:
5631 case CHARSETID:
5632 case CHARSETFORM:
5633 case ACCEPT:
5634 case ACCESSIBLE:
5635 case COPY:
5636 case DEFINE:
5637 case DISCONNECT:
5638 case HOST:
5639 case PRINT:
5640 case QUIT:
5641 case REMARK:
5642 case UNDEFINE:
5643 case VARIABLE:
5644 case WHENEVER:
5645 case ATTACH:
5646 case CAST:
5647 case TREAT:
5648 case TRIM:
5649 case LEFT:
5650 case RIGHT:
5651 case BOTH:
5652 case EMPTY:
5653 case MULTISET:
5654 case SUBMULTISET:
5655 case LEADING:
5656 case TRAILING:
5657 case CHAR_CS:
5658 case NCHAR_CS:
5659 case DBTIMEZONE:
5660 case SESSIONTIMEZONE:
5661 case AUTHENTICATED:
5662 case LINK:
5663 case SHARED:
5664 case DIRECTORY:
5665 case USER:
5666 case IDENTIFIER:
5667 case QUOTED_LITERAL:
5668 case SQLDATA_CLASS:
5669 case CUSTOMDATUM_CLASS:
5670 case ORADATA_CLASS:
5671 case JAVA_INTERFACE_CLASS:
5672 DeclarativeSection();
5673 jj_consume_token(BEGIN);
5674 switch (jj_nt.kind) {
5675 case PRAGMA:
5676 Pragma();
5677 break;
5678 default:
5679 jj_la1[64] = jj_gen;
5680 ;
5681 }
5682 label_16:
5683 while (true) {
5684 switch (jj_nt.kind) {
5685 case 5:
5686 case 16:
5687 case 17:
5688 case 21:
5689 case REPLACE:
5690 case DEFINER:
5691 case CURRENT_USER:
5692 case LANGUAGE:
5693 case INLINE:
5694 case ADD:
5695 case AGGREGATE:
5696 case ARRAY:
5697 case AT:
5698 case ATTRIBUTE:
5699 case AUTHID:
5700 case BEGIN:
5701 case BODY:
5702 case BULK:
5703 case BYTE:
5704 case CASCADE:
5705 case CASE:
5706 case CLOSE:
5707 case COALESCE:
5708 case COLLECT:
5709 case COLUMN:
5710 case COMMENT:
5711 case COMMIT:
5712 case CONSTRUCTOR:
5713 case CONTINUE:
5714 case CONVERT:
5715 case CURRENT:
5716 case CURSOR:
5717 case DATA:
5718 case DATE:
5719 case DAY:
5720 case DECLARE:
5721 case DELETE:
5722 case DISABLE:
5723 case EDITIONABLE:
5724 case ELEMENT:
5725 case ENABLE:
5726 case ESCAPE:
5727 case EXCEPT:
5728 case EXCEPTIONS:
5729 case EXECUTE:
5730 case EXIT:
5731 case EXTERNAL:
5732 case EXTENDS:
5733 case EXTRACT:
5734 case FALSE:
5735 case FETCH:
5736 case FINAL:
5737 case FOR:
5738 case FORALL:
5739 case FORCE:
5740 case FUNCTION:
5741 case GLOBAL:
5742 case GOTO:
5743 case HASH:
5744 case HEAP:
5745 case HOUR:
5746 case IF:
5747 case IMMEDIATE:
5748 case INDICES:
5749 case INDEXTYPE:
5750 case INDICATOR:
5751 case INSERT:
5752 case INSTANTIABLE:
5753 case INTERVAL:
5754 case INVALIDATE:
5755 case ISOLATION:
5756 case JAVA:
5757 case LEVEL:
5758 case LIMIT:
5759 case LOCK:
5760 case LOOP:
5761 case MAP:
5762 case MAX:
5763 case MEMBER:
5764 case MERGE:
5765 case MIN:
5766 case MINUTE:
5767 case MLSLABEL:
5768 case MODIFY:
5769 case MOD:
5770 case MONTH:
5771 case NATURAL:
5772 case NEW:
5773 case NEW_DOT:
5774 case NO:
5775 case NONEDITIONABLE:
5776 case NOT:
5777 case NULL:
5778 case NULLIF:
5779 case OBJECT:
5780 case OID:
5781 case OPAQUE:
5782 case OPEN:
5783 case OPERATOR:
5784 case ORGANIZATION:
5785 case OTHERS:
5786 case OVERRIDING:
5787 case PACKAGE:
5788 case PARTITION:
5789 case PIPE:
5790 case PRAGMA:
5791 case PRESERVE:
5792 case PRIVATE:
5793 case PROCEDURE:
5794 case RAISE:
5795 case RANGE:
5796 case RAW:
5797 case REAL:
5798 case RECORD:
5799 case REF:
5800 case RELEASE:
5801 case RELIES_ON:
5802 case RENAME:
5803 case RESULT:
5804 case RETURN:
5805 case RETURNING:
5806 case REVERSE:
5807 case ROLLBACK:
5808 case ROW:
5809 case ROWS:
5810 case ROWID:
5811 case ROWNUM:
5812 case SAVE:
5813 case SAVEPOINT:
5814 case SECOND:
5815 case SELECT:
5816 case SELF:
5817 case SET:
5818 case SPACE:
5819 case SQL:
5820 case SQLCODE:
5821 case SQLERRM:
5822 case STATIC:
5823 case SUBTYPE:
5824 case SUBSTITUTABLE:
5825 case SUCCESSFUL:
5826 case SYSDATE:
5827 case SYS_REFCURSOR:
5828 case TEMPORARY:
5829 case TIME:
5830 case TIMESTAMP:
5831 case TIMEZONE_REGION:
5832 case TIMEZONE_ABBR:
5833 case TIMEZONE_MINUTE:
5834 case TIMEZONE_HOUR:
5835 case TRANSACTION:
5836 case TRUE:
5837 case TYPE:
5838 case UNDER:
5839 case USING:
5840 case WHILE:
5841 case YES:
5842 case SHOW:
5843 case A:
5844 case UPDATE:
5845 case DOUBLE:
5846 case DEC:
5847 case PRECISION:
5848 case INT:
5849 case NUMERIC:
5850 case NCHAR:
5851 case NVARCHAR2:
5852 case STRING:
5853 case UROWID:
5854 case VARRAY:
5855 case VARYING:
5856 case BFILE:
5857 case BLOB:
5858 case CLOB:
5859 case NCLOB:
5860 case YEAR:
5861 case LOCAL:
5862 case WITH:
5863 case ZONE:
5864 case CHARACTER:
5865 case AFTER:
5866 case BEFORE:
5867 case OLD:
5868 case PARENT:
5869 case CC_IF:
5870 case CC_ERROR:
5871 case ANALYZE:
5872 case ASSOCIATE:
5873 case AUDIT:
5874 case COMPOUND:
5875 case DATABASE:
5876 case CALL:
5877 case DDL:
5878 case DISASSOCIATE:
5879 case EACH:
5880 case FOLLOWS:
5881 case LOGOFF:
5882 case LOGON:
5883 case NESTED:
5884 case NOAUDIT:
5885 case SCHEMA:
5886 case SERVERERROR:
5887 case SHUTDOWN:
5888 case STARTUP:
5889 case STATEMENT:
5890 case STATISTICS:
5891 case SUSPEND:
5892 case TRUNCATE:
5893 case WRAPPED:
5894 case LIBRARY:
5895 case NAME:
5896 case STRUCT:
5897 case CONTEXT:
5898 case PARAMETERS:
5899 case LENGTH:
5900 case TDO:
5901 case MAXLEN:
5902 case CHARSETID:
5903 case CHARSETFORM:
5904 case ACCEPT:
5905 case ACCESSIBLE:
5906 case COPY:
5907 case DEFINE:
5908 case DISCONNECT:
5909 case HOST:
5910 case PRINT:
5911 case QUIT:
5912 case REMARK:
5913 case UNDEFINE:
5914 case VARIABLE:
5915 case WHENEVER:
5916 case ATTACH:
5917 case CAST:
5918 case TREAT:
5919 case TRIM:
5920 case LEFT:
5921 case RIGHT:
5922 case BOTH:
5923 case EMPTY:
5924 case MULTISET:
5925 case SUBMULTISET:
5926 case LEADING:
5927 case TRAILING:
5928 case CHAR_CS:
5929 case NCHAR_CS:
5930 case DBTIMEZONE:
5931 case SESSIONTIMEZONE:
5932 case AUTHENTICATED:
5933 case LINK:
5934 case SHARED:
5935 case DIRECTORY:
5936 case USER:
5937 case IDENTIFIER:
5938 case UNSIGNED_NUMERIC_LITERAL:
5939 case CHARACTER_LITERAL:
5940 case STRING_LITERAL:
5941 case QUOTED_LITERAL:
5942 ;
5943 break;
5944 default:
5945 jj_la1[65] = jj_gen;
5946 break label_16;
5947 }
5948 Statement();
5949 }
5950 switch (jj_nt.kind) {
5951 case EXCEPTION:
5952 ExceptionHandler();
5953 break;
5954 default:
5955 jj_la1[66] = jj_gen;
5956 ;
5957 }
5958 jj_consume_token(END);
5959 switch (jj_nt.kind) {
5960 case REPLACE:
5961 case DEFINER:
5962 case CURRENT_USER:
5963 case SERIALLY_REUSABLE:
5964 case RESTRICT_REFERENCES:
5965 case EXCEPTION_INIT:
5966 case AUTONOMOUS_TRANSACTION:
5967 case LANGUAGE:
5968 case INLINE:
5969 case ADD:
5970 case AGGREGATE:
5971 case ALL:
5972 case ALTER:
5973 case AND:
5974 case ANY:
5975 case ARRAY:
5976 case AS:
5977 case ASC:
5978 case AT:
5979 case ATTRIBUTE:
5980 case AUTHID:
5981 case AVG:
5982 case BETWEEN:
5983 case BINARY_INTEGER:
5984 case BODY:
5985 case BOOLEAN:
5986 case BULK:
5987 case BY:
5988 case BYTE:
5989 case CASCADE:
5990 case CASE:
5991 case CHAR:
5992 case CHAR_BASE:
5993 case CHECK:
5994 case CLOSE:
5995 case CLUSTER:
5996 case COALESCE:
5997 case COLLECT:
5998 case COLUMN:
5999 case COMMENT:
6000 case COMMIT:
6001 case COMPRESS:
6002 case CONNECT:
6003 case CONSTANT:
6004 case CONSTRUCTOR:
6005 case CONTINUE:
6006 case CONVERT:
6007 case CREATE:
6008 case CURRENT:
6009 case CURRVAL:
6010 case CURSOR:
6011 case DATA:
6012 case DATE:
6013 case DAY:
6014 case DECLARE:
6015 case DECIMAL:
6016 case _DEFAULT:
6017 case DELETE:
6018 case DESC:
6019 case DISABLE:
6020 case DISTINCT:
6021 case DO:
6022 case DROP:
6023 case EDITIONABLE:
6024 case ELEMENT:
6025 case ELSE:
6026 case ELSIF:
6027 case ENABLE:
6028 case ESCAPE:
6029 case EXCEPT:
6030 case EXCEPTION:
6031 case EXCEPTIONS:
6032 case EXCLUSIVE:
6033 case EXECUTE:
6034 case EXISTS:
6035 case EXIT:
6036 case EXTERNAL:
6037 case EXTENDS:
6038 case EXTRACT:
6039 case FALSE:
6040 case FETCH:
6041 case FINAL:
6042 case FLOAT:
6043 case FOR:
6044 case FORALL:
6045 case FORCE:
6046 case FROM:
6047 case FUNCTION:
6048 case GLOBAL:
6049 case GOTO:
6050 case GROUP:
6051 case HASH:
6052 case HAVING:
6053 case HEAP:
6054 case HOUR:
6055 case IF:
6056 case IMMEDIATE:
6057 case IN:
6058 case INDEX:
6059 case INDICES:
6060 case INDEXTYPE:
6061 case INDICATOR:
6062 case INSERT:
6063 case INSTANTIABLE:
6064 case INTEGER:
6065 case INTERFACE:
6066 case INTERSECT:
6067 case INTERVAL:
6068 case INTO:
6069 case INVALIDATE:
6070 case IS:
6071 case ISOLATION:
6072 case JAVA:
6073 case LEVEL:
6074 case LIKE:
6075 case LIMIT:
6076 case LIMITED:
6077 case LOCK:
6078 case LONG:
6079 case LOOP:
6080 case MAP:
6081 case MAX:
6082 case MEMBER:
6083 case MERGE:
6084 case MIN:
6085 case MINUS:
6086 case MINUTE:
6087 case MLSLABEL:
6088 case MODIFY:
6089 case MOD:
6090 case MODE:
6091 case MONTH:
6092 case NATURAL:
6093 case NATURALN:
6094 case NEW:
6095 case NEXTVAL:
6096 case NO:
6097 case NOCOPY:
6098 case NONEDITIONABLE:
6099 case NOT:
6100 case NOWAIT:
6101 case NULL:
6102 case NULLIF:
6103 case NUMBER:
6104 case BFILE_BASE:
6105 case BLOB_BASE:
6106 case CLOB_BASE:
6107 case DATE_BASE:
6108 case NUMBER_BASE:
6109 case OBJECT:
6110 case OCIROWID:
6111 case OF:
6112 case OID:
6113 case ON:
6114 case OPAQUE:
6115 case OPEN:
6116 case OPERATOR:
6117 case OPTION:
6118 case OR:
6119 case ORDER:
6120 case ORGANIZATION:
6121 case OTHERS:
6122 case OUT:
6123 case OVERRIDING:
6124 case PACKAGE:
6125 case PARTITION:
6126 case PCTFREE:
6127 case PLS_INTEGER:
6128 case POSITIVE:
6129 case POSITIVEN:
6130 case PRESERVE:
6131 case PRIOR:
6132 case PROMPT:
6133 case PRIVATE:
6134 case PROCEDURE:
6135 case PUBLIC:
6136 case RAISE:
6137 case RANGE:
6138 case RAW:
6139 case REAL:
6140 case RECORD:
6141 case REF:
6142 case RELEASE:
6143 case RELIES_ON:
6144 case RENAME:
6145 case RESULT:
6146 case RETURN:
6147 case RETURNING:
6148 case REVERSE:
6149 case ROLLBACK:
6150 case ROW:
6151 case ROWS:
6152 case ROWID:
6153 case ROWNUM:
6154 case ROWTYPE:
6155 case SAVE:
6156 case SAVEPOINT:
6157 case SECOND:
6158 case SELECT:
6159 case SELF:
6160 case SEPARATE:
6161 case SET:
6162 case SHARE:
6163 case SMALLINT:
6164 case SPACE:
6165 case SQL:
6166 case SQLCODE:
6167 case SQLERRM:
6168 case START:
6169 case STATIC:
6170 case STDDEV:
6171 case SUBTYPE:
6172 case SUBSTITUTABLE:
6173 case SUCCESSFUL:
6174 case SUM:
6175 case SYNONYM:
6176 case SYSDATE:
6177 case SYS_REFCURSOR:
6178 case TABLE:
6179 case TEMPORARY:
6180 case THEN:
6181 case TIME:
6182 case TIMESTAMP:
6183 case TIMEZONE_REGION:
6184 case TIMEZONE_ABBR:
6185 case TIMEZONE_MINUTE:
6186 case TIMEZONE_HOUR:
6187 case TO:
6188 case TRANSACTION:
6189 case TRIGGER:
6190 case TRUE:
6191 case TYPE:
6192 case UI:
6193 case UNDER:
6194 case USING:
6195 case WHILE:
6196 case YES:
6197 case SHOW:
6198 case A:
6199 case UPDATE:
6200 case VARCHAR:
6201 case VARCHAR2:
6202 case DOUBLE:
6203 case DEC:
6204 case PRECISION:
6205 case INT:
6206 case NUMERIC:
6207 case SIGNTYPE:
6208 case NCHAR:
6209 case NVARCHAR2:
6210 case STRING:
6211 case UROWID:
6212 case VARRAY:
6213 case VARYING:
6214 case BFILE:
6215 case BLOB:
6216 case CLOB:
6217 case NCLOB:
6218 case YEAR:
6219 case LOCAL:
6220 case WITH:
6221 case ZONE:
6222 case CHARACTER:
6223 case AFTER:
6224 case BEFORE:
6225 case OLD:
6226 case PARENT:
6227 case ANALYZE:
6228 case ASSOCIATE:
6229 case AUDIT:
6230 case COMPOUND:
6231 case DATABASE:
6232 case CALL:
6233 case DDL:
6234 case DISASSOCIATE:
6235 case EACH:
6236 case FOLLOWS:
6237 case LOGOFF:
6238 case LOGON:
6239 case NESTED:
6240 case NOAUDIT:
6241 case SCHEMA:
6242 case SERVERERROR:
6243 case SHUTDOWN:
6244 case STARTUP:
6245 case STATEMENT:
6246 case STATISTICS:
6247 case SUSPEND:
6248 case TRUNCATE:
6249 case WRAPPED:
6250 case LIBRARY:
6251 case NAME:
6252 case STRUCT:
6253 case CONTEXT:
6254 case PARAMETERS:
6255 case LENGTH:
6256 case TDO:
6257 case MAXLEN:
6258 case CHARSETID:
6259 case CHARSETFORM:
6260 case ACCEPT:
6261 case ACCESSIBLE:
6262 case COPY:
6263 case DEFINE:
6264 case DISCONNECT:
6265 case HOST:
6266 case PRINT:
6267 case QUIT:
6268 case REMARK:
6269 case UNDEFINE:
6270 case VARIABLE:
6271 case WHENEVER:
6272 case ATTACH:
6273 case CAST:
6274 case TREAT:
6275 case TRIM:
6276 case LEFT:
6277 case RIGHT:
6278 case BOTH:
6279 case EMPTY:
6280 case MULTISET:
6281 case SUBMULTISET:
6282 case LEADING:
6283 case TRAILING:
6284 case CHAR_CS:
6285 case NCHAR_CS:
6286 case DBTIMEZONE:
6287 case SESSIONTIMEZONE:
6288 case AUTHENTICATED:
6289 case LINK:
6290 case SHARED:
6291 case DIRECTORY:
6292 case USER:
6293 case IDENTIFIER:
6294 case QUOTED_LITERAL:
6295 case SQLDATA_CLASS:
6296 case CUSTOMDATUM_CLASS:
6297 case ORADATA_CLASS:
6298 case JAVA_INTERFACE_CLASS:
6299 ID();
6300 break;
6301 default:
6302 jj_la1[67] = jj_gen;
6303 ;
6304 }
6305 break;
6306 default:
6307 jj_la1[68] = jj_gen;
6308 jj_consume_token(-1);
6309 throw new ParseException();
6310 }
6311 }
6312 break;
6313 default:
6314 jj_la1[69] = jj_gen;
6315 ;
6316 }
6317 jj_consume_token(4);
6318 break;
6319 default:
6320 jj_la1[70] = jj_gen;
6321 jj_consume_token(-1);
6322 throw new ParseException();
6323 }
6324 jjtree.closeNodeScope(jjtn000, true);
6325 jjtc000 = false;
6326 {if (true) return jjtn000 ;}
6327 } catch (Throwable jjte000) {
6328 if (jjtc000) {
6329 jjtree.clearNodeScope(jjtn000);
6330 jjtc000 = false;
6331 } else {
6332 jjtree.popNode();
6333 }
6334 if (jjte000 instanceof RuntimeException) {
6335 {if (true) throw (RuntimeException)jjte000;}
6336 }
6337 if (jjte000 instanceof ParseException) {
6338 {if (true) throw (ParseException)jjte000;}
6339 }
6340 {if (true) throw (Error)jjte000;}
6341 } finally {
6342 if (jjtc000) {
6343 jjtree.closeNodeScope(jjtn000, true);
6344 }
6345 }
6346 throw new Error("Missing return statement in function");
6347 }
6348
6349 final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6350
6351 ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6352 boolean jjtc000 = true;
6353 jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6354 try {
6355 if (jj_2_22(2)) {
6356 schemaName = ID();
6357 jj_consume_token(3);
6358 } else {
6359 ;
6360 }
6361 objectName = ID();
6362 jjtn000.setImage( (null == schemaName) ? objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() ) ) ;
6363 jjtree.closeNodeScope(jjtn000, true);
6364 jjtc000 = false;
6365 {if (true) return jjtn000 ;}
6366 } catch (Throwable jjte000) {
6367 if (jjtc000) {
6368 jjtree.clearNodeScope(jjtn000);
6369 jjtc000 = false;
6370 } else {
6371 jjtree.popNode();
6372 }
6373 if (jjte000 instanceof RuntimeException) {
6374 {if (true) throw (RuntimeException)jjte000;}
6375 }
6376 if (jjte000 instanceof ParseException) {
6377 {if (true) throw (ParseException)jjte000;}
6378 }
6379 {if (true) throw (Error)jjte000;}
6380 } finally {
6381 if (jjtc000) {
6382 jjtree.closeNodeScope(jjtn000, true);
6383 }
6384 }
6385 throw new Error("Missing return statement in function");
6386 }
6387
6388 final public ASTFormalParameter FormalParameter() throws ParseException {
6389
6390 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6391 boolean jjtc000 = true;
6392 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6393 try {
6394 simpleNode = ID();
6395 if (jj_2_25(2)) {
6396 if (jj_2_24(2)) {
6397 switch (jj_nt.kind) {
6398 case OUT:
6399 jj_consume_token(OUT);
6400 break;
6401 case IN:
6402 jj_consume_token(IN);
6403 jj_consume_token(OUT);
6404 break;
6405 default:
6406 jj_la1[71] = jj_gen;
6407 jj_consume_token(-1);
6408 throw new ParseException();
6409 }
6410 if (jj_2_23(2)) {
6411 jj_consume_token(NOCOPY);
6412 } else {
6413 ;
6414 }
6415 } else {
6416 switch (jj_nt.kind) {
6417 case IN:
6418 jj_consume_token(IN);
6419 break;
6420 default:
6421 jj_la1[72] = jj_gen;
6422 jj_consume_token(-1);
6423 throw new ParseException();
6424 }
6425 }
6426 } else {
6427 ;
6428 }
6429 switch (jj_nt.kind) {
6430 case 8:
6431 jj_consume_token(8);
6432 break;
6433 case REPLACE:
6434 case DEFINER:
6435 case CURRENT_USER:
6436 case LANGUAGE:
6437 case INLINE:
6438 case ADD:
6439 case AGGREGATE:
6440 case ARRAY:
6441 case AT:
6442 case ATTRIBUTE:
6443 case AUTHID:
6444 case BINARY_INTEGER:
6445 case BODY:
6446 case BOOLEAN:
6447 case BULK:
6448 case BYTE:
6449 case CASCADE:
6450 case CHAR:
6451 case CHAR_BASE:
6452 case CLOSE:
6453 case COALESCE:
6454 case COLLECT:
6455 case COLUMN:
6456 case COMMENT:
6457 case COMMIT:
6458 case CONSTRUCTOR:
6459 case CONTINUE:
6460 case CONVERT:
6461 case CURRENT:
6462 case CURSOR:
6463 case DATA:
6464 case DATE:
6465 case DAY:
6466 case DECIMAL:
6467 case DISABLE:
6468 case EDITIONABLE:
6469 case ELEMENT:
6470 case ENABLE:
6471 case ESCAPE:
6472 case EXCEPT:
6473 case EXCEPTIONS:
6474 case EXIT:
6475 case EXTERNAL:
6476 case EXTENDS:
6477 case EXTRACT:
6478 case FALSE:
6479 case FINAL:
6480 case FLOAT:
6481 case FORCE:
6482 case FUNCTION:
6483 case GLOBAL:
6484 case HASH:
6485 case HEAP:
6486 case HOUR:
6487 case IMMEDIATE:
6488 case INDICES:
6489 case INDEXTYPE:
6490 case INDICATOR:
6491 case INSTANTIABLE:
6492 case INTEGER:
6493 case INTERVAL:
6494 case INVALIDATE:
6495 case ISOLATION:
6496 case JAVA:
6497 case LEVEL:
6498 case LIMIT:
6499 case LONG:
6500 case LOOP:
6501 case MAP:
6502 case MAX:
6503 case MEMBER:
6504 case MERGE:
6505 case MIN:
6506 case MINUTE:
6507 case MLSLABEL:
6508 case MODIFY:
6509 case MOD:
6510 case MONTH:
6511 case NATURAL:
6512 case NATURALN:
6513 case NEW:
6514 case NO:
6515 case NONEDITIONABLE:
6516 case NULLIF:
6517 case NUMBER:
6518 case BFILE_BASE:
6519 case BLOB_BASE:
6520 case CLOB_BASE:
6521 case DATE_BASE:
6522 case NUMBER_BASE:
6523 case OBJECT:
6524 case OID:
6525 case OPAQUE:
6526 case OPEN:
6527 case OPERATOR:
6528 case ORGANIZATION:
6529 case OTHERS:
6530 case OVERRIDING:
6531 case PACKAGE:
6532 case PARTITION:
6533 case PLS_INTEGER:
6534 case POSITIVE:
6535 case POSITIVEN:
6536 case PRESERVE:
6537 case PRIVATE:
6538 case PROCEDURE:
6539 case RANGE:
6540 case RAW:
6541 case REAL:
6542 case RECORD:
6543 case REF:
6544 case RELEASE:
6545 case RELIES_ON:
6546 case RENAME:
6547 case RESULT:
6548 case RETURN:
6549 case RETURNING:
6550 case REVERSE:
6551 case ROLLBACK:
6552 case ROW:
6553 case ROWS:
6554 case ROWID:
6555 case ROWNUM:
6556 case SAVE:
6557 case SAVEPOINT:
6558 case SECOND:
6559 case SELF:
6560 case SET:
6561 case SMALLINT:
6562 case SPACE:
6563 case SQL:
6564 case SQLCODE:
6565 case SQLERRM:
6566 case STATIC:
6567 case SUBTYPE:
6568 case SUBSTITUTABLE:
6569 case SUCCESSFUL:
6570 case SYSDATE:
6571 case SYS_REFCURSOR:
6572 case TEMPORARY:
6573 case TIME:
6574 case TIMESTAMP:
6575 case TIMEZONE_REGION:
6576 case TIMEZONE_ABBR:
6577 case TIMEZONE_MINUTE:
6578 case TIMEZONE_HOUR:
6579 case TRANSACTION:
6580 case TRUE:
6581 case TYPE:
6582 case UNDER:
6583 case USING:
6584 case YES:
6585 case SHOW:
6586 case A:
6587 case VARCHAR:
6588 case VARCHAR2:
6589 case DOUBLE:
6590 case DEC:
6591 case PRECISION:
6592 case INT:
6593 case NUMERIC:
6594 case SIGNTYPE:
6595 case NCHAR:
6596 case NVARCHAR2:
6597 case STRING:
6598 case UROWID:
6599 case VARRAY:
6600 case VARYING:
6601 case BFILE:
6602 case BLOB:
6603 case CLOB:
6604 case NCLOB:
6605 case YEAR:
6606 case LOCAL:
6607 case ZONE:
6608 case CHARACTER:
6609 case AFTER:
6610 case BEFORE:
6611 case OLD:
6612 case PARENT:
6613 case CC_IF:
6614 case ANALYZE:
6615 case ASSOCIATE:
6616 case AUDIT:
6617 case COMPOUND:
6618 case DATABASE:
6619 case CALL:
6620 case DDL:
6621 case DISASSOCIATE:
6622 case EACH:
6623 case FOLLOWS:
6624 case LOGOFF:
6625 case LOGON:
6626 case NESTED:
6627 case NOAUDIT:
6628 case SCHEMA:
6629 case SERVERERROR:
6630 case SHUTDOWN:
6631 case STARTUP:
6632 case STATEMENT:
6633 case STATISTICS:
6634 case SUSPEND:
6635 case TRUNCATE:
6636 case WRAPPED:
6637 case LIBRARY:
6638 case NAME:
6639 case STRUCT:
6640 case CONTEXT:
6641 case PARAMETERS:
6642 case LENGTH:
6643 case TDO:
6644 case MAXLEN:
6645 case CHARSETID:
6646 case CHARSETFORM:
6647 case ACCEPT:
6648 case ACCESSIBLE:
6649 case COPY:
6650 case DEFINE:
6651 case DISCONNECT:
6652 case HOST:
6653 case PRINT:
6654 case QUIT:
6655 case REMARK:
6656 case UNDEFINE:
6657 case VARIABLE:
6658 case WHENEVER:
6659 case ATTACH:
6660 case CAST:
6661 case TREAT:
6662 case TRIM:
6663 case LEFT:
6664 case RIGHT:
6665 case BOTH:
6666 case EMPTY:
6667 case MULTISET:
6668 case SUBMULTISET:
6669 case LEADING:
6670 case TRAILING:
6671 case CHAR_CS:
6672 case NCHAR_CS:
6673 case DBTIMEZONE:
6674 case SESSIONTIMEZONE:
6675 case AUTHENTICATED:
6676 case LINK:
6677 case SHARED:
6678 case DIRECTORY:
6679 case USER:
6680 case IDENTIFIER:
6681 case QUOTED_LITERAL:
6682 Datatype();
6683 break;
6684 default:
6685 jj_la1[73] = jj_gen;
6686 jj_consume_token(-1);
6687 throw new ParseException();
6688 }
6689 switch (jj_nt.kind) {
6690 case 9:
6691 case _DEFAULT:
6692 switch (jj_nt.kind) {
6693 case 9:
6694 jj_consume_token(9);
6695 jj_consume_token(10);
6696 break;
6697 case _DEFAULT:
6698 jj_consume_token(_DEFAULT);
6699 break;
6700 default:
6701 jj_la1[74] = jj_gen;
6702 jj_consume_token(-1);
6703 throw new ParseException();
6704 }
6705 Expression();
6706 break;
6707 default:
6708 jj_la1[75] = jj_gen;
6709 ;
6710 }
6711 jjtree.closeNodeScope(jjtn000, true);
6712 jjtc000 = false;
6713 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6714 } catch (Throwable jjte000) {
6715 if (jjtc000) {
6716 jjtree.clearNodeScope(jjtn000);
6717 jjtc000 = false;
6718 } else {
6719 jjtree.popNode();
6720 }
6721 if (jjte000 instanceof RuntimeException) {
6722 {if (true) throw (RuntimeException)jjte000;}
6723 }
6724 if (jjte000 instanceof ParseException) {
6725 {if (true) throw (ParseException)jjte000;}
6726 }
6727 {if (true) throw (Error)jjte000;}
6728 } finally {
6729 if (jjtc000) {
6730 jjtree.closeNodeScope(jjtn000, true);
6731 }
6732 }
6733 throw new Error("Missing return statement in function");
6734 }
6735
6736 final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6737
6738 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6739 boolean jjtc000 = true;
6740 jjtree.openNodeScope(jjtn000);
6741 try {
6742 switch (jj_nt.kind) {
6743 case CREATE:
6744 case FUNCTION:
6745 case PROCEDURE:
6746 ProgramUnit();
6747 break;
6748 case CONSTRUCTOR:
6749 case FINAL:
6750 case INSTANTIABLE:
6751 case MAP:
6752 case MEMBER:
6753 case NOT:
6754 case ORDER:
6755 case OVERRIDING:
6756 case STATIC:
6757 TypeMethod();
6758 break;
6759 default:
6760 jj_la1[76] = jj_gen;
6761 jj_consume_token(-1);
6762 throw new ParseException();
6763 }
6764 jjtree.closeNodeScope(jjtn000, true);
6765 jjtc000 = false;
6766 {if (true) return jjtn000 ;}
6767 } catch (Throwable jjte000) {
6768 if (jjtc000) {
6769 jjtree.clearNodeScope(jjtn000);
6770 jjtc000 = false;
6771 } else {
6772 jjtree.popNode();
6773 }
6774 if (jjte000 instanceof RuntimeException) {
6775 {if (true) throw (RuntimeException)jjte000;}
6776 }
6777 if (jjte000 instanceof ParseException) {
6778 {if (true) throw (ParseException)jjte000;}
6779 }
6780 {if (true) throw (Error)jjte000;}
6781 } finally {
6782 if (jjtc000) {
6783 jjtree.closeNodeScope(jjtn000, true);
6784 }
6785 }
6786 throw new Error("Missing return statement in function");
6787 }
6788
6789 final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6790
6791 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6792 boolean jjtc000 = true;
6793 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6794 try {
6795 switch (jj_nt.kind) {
6796 case FUNCTION:
6797 jj_consume_token(FUNCTION);
6798 simpleNode = ObjectNameDeclaration();
6799 switch (jj_nt.kind) {
6800 case 5:
6801 FormalParameters();
6802 break;
6803 default:
6804 jj_la1[77] = jj_gen;
6805 ;
6806 }
6807 Token nextToken;
6808 nextToken = getToken(1);
6809 if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6810 &&
6811 !nextToken.image.equalsIgnoreCase("RETURN")
6812 )
6813 {
6814 {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6815 + nextToken.image
6816 + "\u005c" at line "+nextToken.beginLine
6817 + ", column "+nextToken.beginColumn
6818 );}
6819 }
6820 switch (jj_nt.kind) {
6821 case RETURN:
6822 jj_consume_token(RETURN);
6823 Datatype();
6824 break;
6825 default:
6826 jj_la1[78] = jj_gen;
6827 ;
6828 }
6829 break;
6830 case PROCEDURE:
6831 jj_consume_token(PROCEDURE);
6832 simpleNode = ObjectNameDeclaration();
6833 switch (jj_nt.kind) {
6834 case 5:
6835 FormalParameters();
6836 break;
6837 default:
6838 jj_la1[79] = jj_gen;
6839 ;
6840 }
6841 break;
6842 default:
6843 jj_la1[80] = jj_gen;
6844 jj_consume_token(-1);
6845 throw new ParseException();
6846 }
6847 jjtree.closeNodeScope(jjtn000, true);
6848 jjtc000 = false;
6849 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6850 } catch (Throwable jjte000) {
6851 if (jjtc000) {
6852 jjtree.clearNodeScope(jjtn000);
6853 jjtc000 = false;
6854 } else {
6855 jjtree.popNode();
6856 }
6857 if (jjte000 instanceof RuntimeException) {
6858 {if (true) throw (RuntimeException)jjte000;}
6859 }
6860 if (jjte000 instanceof ParseException) {
6861 {if (true) throw (ParseException)jjte000;}
6862 }
6863 {if (true) throw (Error)jjte000;}
6864 } finally {
6865 if (jjtc000) {
6866 jjtree.closeNodeScope(jjtn000, true);
6867 }
6868 }
6869 throw new Error("Missing return statement in function");
6870 }
6871
6872 final public ASTFormalParameters FormalParameters() throws ParseException {
6873
6874 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6875 boolean jjtc000 = true;
6876 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6877 StringBuilder sb = new StringBuilder();
6878 try {
6879 jj_consume_token(5);
6880 sb.append("(");
6881 switch (jj_nt.kind) {
6882 case REPLACE:
6883 case DEFINER:
6884 case CURRENT_USER:
6885 case SERIALLY_REUSABLE:
6886 case RESTRICT_REFERENCES:
6887 case EXCEPTION_INIT:
6888 case AUTONOMOUS_TRANSACTION:
6889 case LANGUAGE:
6890 case INLINE:
6891 case ADD:
6892 case AGGREGATE:
6893 case ALL:
6894 case ALTER:
6895 case AND:
6896 case ANY:
6897 case ARRAY:
6898 case AS:
6899 case ASC:
6900 case AT:
6901 case ATTRIBUTE:
6902 case AUTHID:
6903 case AVG:
6904 case BETWEEN:
6905 case BINARY_INTEGER:
6906 case BODY:
6907 case BOOLEAN:
6908 case BULK:
6909 case BY:
6910 case BYTE:
6911 case CASCADE:
6912 case CASE:
6913 case CHAR:
6914 case CHAR_BASE:
6915 case CHECK:
6916 case CLOSE:
6917 case CLUSTER:
6918 case COALESCE:
6919 case COLLECT:
6920 case COLUMN:
6921 case COMMENT:
6922 case COMMIT:
6923 case COMPRESS:
6924 case CONNECT:
6925 case CONSTANT:
6926 case CONSTRUCTOR:
6927 case CONTINUE:
6928 case CONVERT:
6929 case CREATE:
6930 case CURRENT:
6931 case CURRVAL:
6932 case CURSOR:
6933 case DATA:
6934 case DATE:
6935 case DAY:
6936 case DECLARE:
6937 case DECIMAL:
6938 case _DEFAULT:
6939 case DELETE:
6940 case DESC:
6941 case DISABLE:
6942 case DISTINCT:
6943 case DO:
6944 case DROP:
6945 case EDITIONABLE:
6946 case ELEMENT:
6947 case ELSE:
6948 case ELSIF:
6949 case ENABLE:
6950 case ESCAPE:
6951 case EXCEPT:
6952 case EXCEPTION:
6953 case EXCEPTIONS:
6954 case EXCLUSIVE:
6955 case EXECUTE:
6956 case EXISTS:
6957 case EXIT:
6958 case EXTERNAL:
6959 case EXTENDS:
6960 case EXTRACT:
6961 case FALSE:
6962 case FETCH:
6963 case FINAL:
6964 case FLOAT:
6965 case FOR:
6966 case FORALL:
6967 case FORCE:
6968 case FROM:
6969 case FUNCTION:
6970 case GLOBAL:
6971 case GOTO:
6972 case GROUP:
6973 case HASH:
6974 case HAVING:
6975 case HEAP:
6976 case HOUR:
6977 case IF:
6978 case IMMEDIATE:
6979 case IN:
6980 case INDEX:
6981 case INDICES:
6982 case INDEXTYPE:
6983 case INDICATOR:
6984 case INSERT:
6985 case INSTANTIABLE:
6986 case INTEGER:
6987 case INTERFACE:
6988 case INTERSECT:
6989 case INTERVAL:
6990 case INTO:
6991 case INVALIDATE:
6992 case IS:
6993 case ISOLATION:
6994 case JAVA:
6995 case LEVEL:
6996 case LIKE:
6997 case LIMIT:
6998 case LIMITED:
6999 case LOCK:
7000 case LONG:
7001 case LOOP:
7002 case MAP:
7003 case MAX:
7004 case MEMBER:
7005 case MERGE:
7006 case MIN:
7007 case MINUS:
7008 case MINUTE:
7009 case MLSLABEL:
7010 case MODIFY:
7011 case MOD:
7012 case MODE:
7013 case MONTH:
7014 case NATURAL:
7015 case NATURALN:
7016 case NEW:
7017 case NEXTVAL:
7018 case NO:
7019 case NOCOPY:
7020 case NONEDITIONABLE:
7021 case NOT:
7022 case NOWAIT:
7023 case NULL:
7024 case NULLIF:
7025 case NUMBER:
7026 case BFILE_BASE:
7027 case BLOB_BASE:
7028 case CLOB_BASE:
7029 case DATE_BASE:
7030 case NUMBER_BASE:
7031 case OBJECT:
7032 case OCIROWID:
7033 case OF:
7034 case OID:
7035 case ON:
7036 case OPAQUE:
7037 case OPEN:
7038 case OPERATOR:
7039 case OPTION:
7040 case OR:
7041 case ORDER:
7042 case ORGANIZATION:
7043 case OTHERS:
7044 case OUT:
7045 case OVERRIDING:
7046 case PACKAGE:
7047 case PARTITION:
7048 case PCTFREE:
7049 case PLS_INTEGER:
7050 case POSITIVE:
7051 case POSITIVEN:
7052 case PRESERVE:
7053 case PRIOR:
7054 case PROMPT:
7055 case PRIVATE:
7056 case PROCEDURE:
7057 case PUBLIC:
7058 case RAISE:
7059 case RANGE:
7060 case RAW:
7061 case REAL:
7062 case RECORD:
7063 case REF:
7064 case RELEASE:
7065 case RELIES_ON:
7066 case RENAME:
7067 case RESULT:
7068 case RETURN:
7069 case RETURNING:
7070 case REVERSE:
7071 case ROLLBACK:
7072 case ROW:
7073 case ROWS:
7074 case ROWID:
7075 case ROWNUM:
7076 case ROWTYPE:
7077 case SAVE:
7078 case SAVEPOINT:
7079 case SECOND:
7080 case SELECT:
7081 case SELF:
7082 case SEPARATE:
7083 case SET:
7084 case SHARE:
7085 case SMALLINT:
7086 case SPACE:
7087 case SQL:
7088 case SQLCODE:
7089 case SQLERRM:
7090 case START:
7091 case STATIC:
7092 case STDDEV:
7093 case SUBTYPE:
7094 case SUBSTITUTABLE:
7095 case SUCCESSFUL:
7096 case SUM:
7097 case SYNONYM:
7098 case SYSDATE:
7099 case SYS_REFCURSOR:
7100 case TABLE:
7101 case TEMPORARY:
7102 case THEN:
7103 case TIME:
7104 case TIMESTAMP:
7105 case TIMEZONE_REGION:
7106 case TIMEZONE_ABBR:
7107 case TIMEZONE_MINUTE:
7108 case TIMEZONE_HOUR:
7109 case TO:
7110 case TRANSACTION:
7111 case TRIGGER:
7112 case TRUE:
7113 case TYPE:
7114 case UI:
7115 case UNDER:
7116 case USING:
7117 case WHILE:
7118 case YES:
7119 case SHOW:
7120 case A:
7121 case UPDATE:
7122 case VARCHAR:
7123 case VARCHAR2:
7124 case DOUBLE:
7125 case DEC:
7126 case PRECISION:
7127 case INT:
7128 case NUMERIC:
7129 case SIGNTYPE:
7130 case NCHAR:
7131 case NVARCHAR2:
7132 case STRING:
7133 case UROWID:
7134 case VARRAY:
7135 case VARYING:
7136 case BFILE:
7137 case BLOB:
7138 case CLOB:
7139 case NCLOB:
7140 case YEAR:
7141 case LOCAL:
7142 case WITH:
7143 case ZONE:
7144 case CHARACTER:
7145 case AFTER:
7146 case BEFORE:
7147 case OLD:
7148 case PARENT:
7149 case ANALYZE:
7150 case ASSOCIATE:
7151 case AUDIT:
7152 case COMPOUND:
7153 case DATABASE:
7154 case CALL:
7155 case DDL:
7156 case DISASSOCIATE:
7157 case EACH:
7158 case FOLLOWS:
7159 case LOGOFF:
7160 case LOGON:
7161 case NESTED:
7162 case NOAUDIT:
7163 case SCHEMA:
7164 case SERVERERROR:
7165 case SHUTDOWN:
7166 case STARTUP:
7167 case STATEMENT:
7168 case STATISTICS:
7169 case SUSPEND:
7170 case TRUNCATE:
7171 case WRAPPED:
7172 case LIBRARY:
7173 case NAME:
7174 case STRUCT:
7175 case CONTEXT:
7176 case PARAMETERS:
7177 case LENGTH:
7178 case TDO:
7179 case MAXLEN:
7180 case CHARSETID:
7181 case CHARSETFORM:
7182 case ACCEPT:
7183 case ACCESSIBLE:
7184 case COPY:
7185 case DEFINE:
7186 case DISCONNECT:
7187 case HOST:
7188 case PRINT:
7189 case QUIT:
7190 case REMARK:
7191 case UNDEFINE:
7192 case VARIABLE:
7193 case WHENEVER:
7194 case ATTACH:
7195 case CAST:
7196 case TREAT:
7197 case TRIM:
7198 case LEFT:
7199 case RIGHT:
7200 case BOTH:
7201 case EMPTY:
7202 case MULTISET:
7203 case SUBMULTISET:
7204 case LEADING:
7205 case TRAILING:
7206 case CHAR_CS:
7207 case NCHAR_CS:
7208 case DBTIMEZONE:
7209 case SESSIONTIMEZONE:
7210 case AUTHENTICATED:
7211 case LINK:
7212 case SHARED:
7213 case DIRECTORY:
7214 case USER:
7215 case IDENTIFIER:
7216 case QUOTED_LITERAL:
7217 case SQLDATA_CLASS:
7218 case CUSTOMDATUM_CLASS:
7219 case ORADATA_CLASS:
7220 case JAVA_INTERFACE_CLASS:
7221 simpleNode = FormalParameter();
7222 sb.append(simpleNode.getImage());
7223 label_17:
7224 while (true) {
7225 switch (jj_nt.kind) {
7226 case 6:
7227 ;
7228 break;
7229 default:
7230 jj_la1[81] = jj_gen;
7231 break label_17;
7232 }
7233 jj_consume_token(6);
7234 simpleNode = FormalParameter();
7235 sb.append(","+simpleNode.getImage());
7236 }
7237 break;
7238 default:
7239 jj_la1[82] = jj_gen;
7240 ;
7241 }
7242 jj_consume_token(7);
7243 sb.append(")");
7244 jjtree.closeNodeScope(jjtn000, true);
7245 jjtc000 = false;
7246 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7247 } catch (Throwable jjte000) {
7248 if (jjtc000) {
7249 jjtree.clearNodeScope(jjtn000);
7250 jjtc000 = false;
7251 } else {
7252 jjtree.popNode();
7253 }
7254 if (jjte000 instanceof RuntimeException) {
7255 {if (true) throw (RuntimeException)jjte000;}
7256 }
7257 if (jjte000 instanceof ParseException) {
7258 {if (true) throw (ParseException)jjte000;}
7259 }
7260 {if (true) throw (Error)jjte000;}
7261 } finally {
7262 if (jjtc000) {
7263 jjtree.closeNodeScope(jjtn000, true);
7264 }
7265 }
7266 throw new Error("Missing return statement in function");
7267 }
7268
7269 final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7270
7271 ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7272 boolean jjtc000 = true;
7273 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7274 StringBuilder sb = new StringBuilder();
7275 try {
7276 simpleNode = VariableOrConstantDeclaratorId();
7277 sb.append(simpleNode.getImage());
7278 if (jj_2_26(2)) {
7279 jj_consume_token(CONSTANT);
7280 sb.append(" " + token.image);
7281 } else {
7282 ;
7283 }
7284 simpleNode = Datatype();
7285 sb.append(" " + simpleNode.getImage());
7286 switch (jj_nt.kind) {
7287 case NOT:
7288 case NULL:
7289 switch (jj_nt.kind) {
7290 case NOT:
7291 jj_consume_token(NOT);
7292 sb.append(" " + token.image);
7293 break;
7294 default:
7295 jj_la1[83] = jj_gen;
7296 ;
7297 }
7298 jj_consume_token(NULL);
7299 sb.append(" " + token.image);
7300 break;
7301 default:
7302 jj_la1[84] = jj_gen;
7303 ;
7304 }
7305 switch (jj_nt.kind) {
7306 case 9:
7307 case _DEFAULT:
7308 switch (jj_nt.kind) {
7309 case 9:
7310 jj_consume_token(9);
7311 jj_consume_token(10);
7312 sb.append(" :=");
7313 break;
7314 case _DEFAULT:
7315 jj_consume_token(_DEFAULT);
7316 sb.append(" " + token.image);
7317 break;
7318 default:
7319 jj_la1[85] = jj_gen;
7320 jj_consume_token(-1);
7321 throw new ParseException();
7322 }
7323 simpleNode = VariableOrConstantInitializer();
7324 sb.append(" " + simpleNode.getImage());
7325 break;
7326 default:
7327 jj_la1[86] = jj_gen;
7328 ;
7329 }
7330 jjtree.closeNodeScope(jjtn000, true);
7331 jjtc000 = false;
7332 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7333 } catch (Throwable jjte000) {
7334 if (jjtc000) {
7335 jjtree.clearNodeScope(jjtn000);
7336 jjtc000 = false;
7337 } else {
7338 jjtree.popNode();
7339 }
7340 if (jjte000 instanceof RuntimeException) {
7341 {if (true) throw (RuntimeException)jjte000;}
7342 }
7343 if (jjte000 instanceof ParseException) {
7344 {if (true) throw (ParseException)jjte000;}
7345 }
7346 {if (true) throw (Error)jjte000;}
7347 } finally {
7348 if (jjtc000) {
7349 jjtree.closeNodeScope(jjtn000, true);
7350 }
7351 }
7352 throw new Error("Missing return statement in function");
7353 }
7354
7355 final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7356
7357 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7358 boolean jjtc000 = true;
7359 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7360 try {
7361 simpleNode = ID();
7362 jjtree.closeNodeScope(jjtn000, true);
7363 jjtc000 = false;
7364 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7365 } catch (Throwable jjte000) {
7366 if (jjtc000) {
7367 jjtree.clearNodeScope(jjtn000);
7368 jjtc000 = false;
7369 } else {
7370 jjtree.popNode();
7371 }
7372 if (jjte000 instanceof RuntimeException) {
7373 {if (true) throw (RuntimeException)jjte000;}
7374 }
7375 if (jjte000 instanceof ParseException) {
7376 {if (true) throw (ParseException)jjte000;}
7377 }
7378 {if (true) throw (Error)jjte000;}
7379 } finally {
7380 if (jjtc000) {
7381 jjtree.closeNodeScope(jjtn000, true);
7382 }
7383 }
7384 throw new Error("Missing return statement in function");
7385 }
7386
7387 final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7388
7389 ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7390 boolean jjtc000 = true;
7391 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7392 try {
7393 simpleNode = Expression();
7394 jjtree.closeNodeScope(jjtn000, true);
7395 jjtc000 = false;
7396 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7397 } catch (Throwable jjte000) {
7398 if (jjtc000) {
7399 jjtree.clearNodeScope(jjtn000);
7400 jjtc000 = false;
7401 } else {
7402 jjtree.popNode();
7403 }
7404 if (jjte000 instanceof RuntimeException) {
7405 {if (true) throw (RuntimeException)jjte000;}
7406 }
7407 if (jjte000 instanceof ParseException) {
7408 {if (true) throw (ParseException)jjte000;}
7409 }
7410 {if (true) throw (Error)jjte000;}
7411 } finally {
7412 if (jjtc000) {
7413 jjtree.closeNodeScope(jjtn000, true);
7414 }
7415 }
7416 throw new Error("Missing return statement in function");
7417 }
7418
7419 final public ASTDatatype Datatype() throws ParseException {
7420
7421 ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7422 boolean jjtc000 = true;
7423 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7424 StringBuilder sb = new StringBuilder();
7425 try {
7426 switch (jj_nt.kind) {
7427 case CC_IF:
7428
7429 simpleNode = CompilationDataType();
7430 sb.append(simpleNode.getImage());
7431 break;
7432 default:
7433 jj_la1[90] = jj_gen;
7434 if (jj_2_28(2)) {
7435 simpleNode = ScalarDataTypeName();
7436 sb.append(simpleNode.getImage());
7437 } else {
7438 switch (jj_nt.kind) {
7439 case REPLACE:
7440 case DEFINER:
7441 case CURRENT_USER:
7442 case LANGUAGE:
7443 case INLINE:
7444 case ADD:
7445 case AGGREGATE:
7446 case ARRAY:
7447 case AT:
7448 case ATTRIBUTE:
7449 case AUTHID:
7450 case BODY:
7451 case BULK:
7452 case BYTE:
7453 case CASCADE:
7454 case CLOSE:
7455 case COALESCE:
7456 case COLLECT:
7457 case COLUMN:
7458 case COMMENT:
7459 case COMMIT:
7460 case CONSTRUCTOR:
7461 case CONTINUE:
7462 case CONVERT:
7463 case CURRENT:
7464 case CURSOR:
7465 case DATA:
7466 case DAY:
7467 case DISABLE:
7468 case EDITIONABLE:
7469 case ELEMENT:
7470 case ENABLE:
7471 case ESCAPE:
7472 case EXCEPT:
7473 case EXCEPTIONS:
7474 case EXIT:
7475 case EXTERNAL:
7476 case EXTENDS:
7477 case EXTRACT:
7478 case FALSE:
7479 case FINAL:
7480 case FORCE:
7481 case FUNCTION:
7482 case GLOBAL:
7483 case HASH:
7484 case HEAP:
7485 case HOUR:
7486 case IMMEDIATE:
7487 case INDICES:
7488 case INDEXTYPE:
7489 case INDICATOR:
7490 case INSTANTIABLE:
7491 case INTERVAL:
7492 case INVALIDATE:
7493 case ISOLATION:
7494 case JAVA:
7495 case LEVEL:
7496 case LIMIT:
7497 case LOOP:
7498 case MAP:
7499 case MAX:
7500 case MEMBER:
7501 case MERGE:
7502 case MIN:
7503 case MINUTE:
7504 case MLSLABEL:
7505 case MODIFY:
7506 case MOD:
7507 case MONTH:
7508 case NATURAL:
7509 case NEW:
7510 case NO:
7511 case NONEDITIONABLE:
7512 case NULLIF:
7513 case OBJECT:
7514 case OID:
7515 case OPAQUE:
7516 case OPEN:
7517 case OPERATOR:
7518 case ORGANIZATION:
7519 case OTHERS:
7520 case OVERRIDING:
7521 case PACKAGE:
7522 case PARTITION:
7523 case PRESERVE:
7524 case PRIVATE:
7525 case PROCEDURE:
7526 case RANGE:
7527 case RAW:
7528 case REAL:
7529 case RECORD:
7530 case REF:
7531 case RELEASE:
7532 case RELIES_ON:
7533 case RENAME:
7534 case RESULT:
7535 case RETURN:
7536 case RETURNING:
7537 case REVERSE:
7538 case ROLLBACK:
7539 case ROW:
7540 case ROWS:
7541 case ROWID:
7542 case ROWNUM:
7543 case SAVE:
7544 case SAVEPOINT:
7545 case SECOND:
7546 case SELF:
7547 case SET:
7548 case SPACE:
7549 case SQL:
7550 case SQLCODE:
7551 case SQLERRM:
7552 case STATIC:
7553 case SUBTYPE:
7554 case SUBSTITUTABLE:
7555 case SUCCESSFUL:
7556 case SYSDATE:
7557 case SYS_REFCURSOR:
7558 case TEMPORARY:
7559 case TIME:
7560 case TIMESTAMP:
7561 case TIMEZONE_REGION:
7562 case TIMEZONE_ABBR:
7563 case TIMEZONE_MINUTE:
7564 case TIMEZONE_HOUR:
7565 case TRANSACTION:
7566 case TRUE:
7567 case TYPE:
7568 case UNDER:
7569 case USING:
7570 case YES:
7571 case SHOW:
7572 case A:
7573 case DOUBLE:
7574 case DEC:
7575 case PRECISION:
7576 case INT:
7577 case NUMERIC:
7578 case NCHAR:
7579 case NVARCHAR2:
7580 case STRING:
7581 case UROWID:
7582 case VARRAY:
7583 case VARYING:
7584 case BFILE:
7585 case BLOB:
7586 case CLOB:
7587 case NCLOB:
7588 case YEAR:
7589 case LOCAL:
7590 case ZONE:
7591 case CHARACTER:
7592 case AFTER:
7593 case BEFORE:
7594 case OLD:
7595 case PARENT:
7596 case ANALYZE:
7597 case ASSOCIATE:
7598 case AUDIT:
7599 case COMPOUND:
7600 case DATABASE:
7601 case CALL:
7602 case DDL:
7603 case DISASSOCIATE:
7604 case EACH:
7605 case FOLLOWS:
7606 case LOGOFF:
7607 case LOGON:
7608 case NESTED:
7609 case NOAUDIT:
7610 case SCHEMA:
7611 case SERVERERROR:
7612 case SHUTDOWN:
7613 case STARTUP:
7614 case STATEMENT:
7615 case STATISTICS:
7616 case SUSPEND:
7617 case TRUNCATE:
7618 case WRAPPED:
7619 case LIBRARY:
7620 case NAME:
7621 case STRUCT:
7622 case CONTEXT:
7623 case PARAMETERS:
7624 case LENGTH:
7625 case TDO:
7626 case MAXLEN:
7627 case CHARSETID:
7628 case CHARSETFORM:
7629 case ACCEPT:
7630 case ACCESSIBLE:
7631 case COPY:
7632 case DEFINE:
7633 case DISCONNECT:
7634 case HOST:
7635 case PRINT:
7636 case QUIT:
7637 case REMARK:
7638 case UNDEFINE:
7639 case VARIABLE:
7640 case WHENEVER:
7641 case ATTACH:
7642 case CAST:
7643 case TREAT:
7644 case TRIM:
7645 case LEFT:
7646 case RIGHT:
7647 case BOTH:
7648 case EMPTY:
7649 case MULTISET:
7650 case SUBMULTISET:
7651 case LEADING:
7652 case TRAILING:
7653 case CHAR_CS:
7654 case NCHAR_CS:
7655 case DBTIMEZONE:
7656 case SESSIONTIMEZONE:
7657 case AUTHENTICATED:
7658 case LINK:
7659 case SHARED:
7660 case DIRECTORY:
7661 case USER:
7662 case IDENTIFIER:
7663 case QUOTED_LITERAL:
7664 if (jj_2_27(2)) {
7665 jj_consume_token(REF);
7666 sb.append(token.image);
7667 } else {
7668 ;
7669 }
7670 simpleNode = QualifiedName();
7671 sb.append(simpleNode.getImage());
7672 switch (jj_nt.kind) {
7673 case 2:
7674 jj_consume_token(2);
7675 simpleNode = QualifiedName();
7676 sb.append("@"+simpleNode.getImage());
7677 break;
7678 default:
7679 jj_la1[87] = jj_gen;
7680 ;
7681 }
7682 switch (jj_nt.kind) {
7683 case 11:
7684 jj_consume_token(11);
7685 switch (jj_nt.kind) {
7686 case TYPE:
7687 jj_consume_token(TYPE);
7688 break;
7689 case ROWTYPE:
7690 jj_consume_token(ROWTYPE);
7691 break;
7692 default:
7693 jj_la1[88] = jj_gen;
7694 jj_consume_token(-1);
7695 throw new ParseException();
7696 }
7697 sb.append("%"+token.image);
7698 break;
7699 default:
7700 jj_la1[89] = jj_gen;
7701 ;
7702 }
7703 break;
7704 default:
7705 jj_la1[91] = jj_gen;
7706 jj_consume_token(-1);
7707 throw new ParseException();
7708 }
7709 }
7710 }
7711 jjtree.closeNodeScope(jjtn000, true);
7712 jjtc000 = false;
7713 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7714 } catch (Throwable jjte000) {
7715 if (jjtc000) {
7716 jjtree.clearNodeScope(jjtn000);
7717 jjtc000 = false;
7718 } else {
7719 jjtree.popNode();
7720 }
7721 if (jjte000 instanceof RuntimeException) {
7722 {if (true) throw (RuntimeException)jjte000;}
7723 }
7724 if (jjte000 instanceof ParseException) {
7725 {if (true) throw (ParseException)jjte000;}
7726 }
7727 {if (true) throw (Error)jjte000;}
7728 } finally {
7729 if (jjtc000) {
7730 jjtree.closeNodeScope(jjtn000, true);
7731 }
7732 }
7733 throw new Error("Missing return statement in function");
7734 }
7735
7736 final public ASTCompilationDataType CompilationDataType() throws ParseException {
7737
7738 ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7739 boolean jjtc000 = true;
7740 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7741 StringBuilder sb = new StringBuilder() ;
7742 try {
7743 jj_consume_token(CC_IF);
7744 sb.append(" "); sb.append(token.image) ;
7745 simpleNode = ConditionalOrExpression();
7746 sb.append(" "); sb.append(simpleNode.getImage());
7747 jj_consume_token(CC_THEN);
7748 sb.append(" "); sb.append(token.image);
7749 simpleNode = Datatype();
7750 sb.append(" "); sb.append(simpleNode.getImage());
7751 label_18:
7752 while (true) {
7753 switch (jj_nt.kind) {
7754 case CC_ELSIF:
7755 ;
7756 break;
7757 default:
7758 jj_la1[92] = jj_gen;
7759 break label_18;
7760 }
7761 jj_consume_token(CC_ELSIF);
7762 sb.append(" "); sb.append(token.image);
7763 simpleNode = ConditionalOrExpression();
7764 sb.append(" "); sb.append(simpleNode.getImage());
7765 jj_consume_token(CC_THEN);
7766 sb.append(" "); sb.append(token.image);
7767 simpleNode = Datatype();
7768 sb.append(" "); sb.append(simpleNode.getImage());
7769 }
7770 label_19:
7771 while (true) {
7772 switch (jj_nt.kind) {
7773 case CC_ELSE:
7774 ;
7775 break;
7776 default:
7777 jj_la1[93] = jj_gen;
7778 break label_19;
7779 }
7780 jj_consume_token(CC_ELSE);
7781 sb.append(" "); sb.append(token.image);
7782 simpleNode = Datatype();
7783 sb.append(" "); sb.append(simpleNode.getImage());
7784 }
7785 jj_consume_token(CC_END);
7786 sb.append(" "); sb.append(token.image);
7787 jjtree.closeNodeScope(jjtn000, true);
7788 jjtc000 = false;
7789 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7790 } catch (Throwable jjte000) {
7791 if (jjtc000) {
7792 jjtree.clearNodeScope(jjtn000);
7793 jjtc000 = false;
7794 } else {
7795 jjtree.popNode();
7796 }
7797 if (jjte000 instanceof RuntimeException) {
7798 {if (true) throw (RuntimeException)jjte000;}
7799 }
7800 if (jjte000 instanceof ParseException) {
7801 {if (true) throw (ParseException)jjte000;}
7802 }
7803 {if (true) throw (Error)jjte000;}
7804 } finally {
7805 if (jjtc000) {
7806 jjtree.closeNodeScope(jjtn000, true);
7807 }
7808 }
7809 throw new Error("Missing return statement in function");
7810 }
7811
7812 final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7813
7814 ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7815 boolean jjtc000 = true;
7816 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7817 StringBuilder sb = new StringBuilder();
7818 try {
7819 switch (jj_nt.kind) {
7820 case TABLE:
7821 jj_consume_token(TABLE);
7822 break;
7823 case VARRAY:
7824 jj_consume_token(VARRAY);
7825 break;
7826 case VARYING:
7827 jj_consume_token(VARYING);
7828 jj_consume_token(ARRAY);
7829 sb.append( "VARYING ARRAY") ;
7830 break;
7831 default:
7832 jj_la1[94] = jj_gen;
7833 jj_consume_token(-1);
7834 throw new ParseException();
7835 }
7836 if (sb.length() == 0) {
7837 sb.append(token.toString());
7838 }
7839 if (jj_2_29(2)) {
7840 jj_consume_token(5);
7841 size = NumericLiteral();
7842 sb.append( "(" + size);
7843 switch (jj_nt.kind) {
7844 case 6:
7845 jj_consume_token(6);
7846 precision = NumericLiteral();
7847 sb.append( "," + precision);
7848 break;
7849 default:
7850 jj_la1[95] = jj_gen;
7851 ;
7852 }
7853 switch (jj_nt.kind) {
7854 case CHAR:
7855 jj_consume_token(CHAR);
7856 sb.append( " CHAR") ;
7857 break;
7858 default:
7859 jj_la1[96] = jj_gen;
7860 ;
7861 }
7862 switch (jj_nt.kind) {
7863 case BYTE:
7864 jj_consume_token(BYTE);
7865 sb.append( " BYTE") ;
7866 break;
7867 default:
7868 jj_la1[97] = jj_gen;
7869 ;
7870 }
7871 jj_consume_token(7);
7872 sb.append( ")");
7873 } else {
7874 ;
7875 }
7876 jjtree.closeNodeScope(jjtn000, true);
7877 jjtc000 = false;
7878 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7879 } catch (Throwable jjte000) {
7880 if (jjtc000) {
7881 jjtree.clearNodeScope(jjtn000);
7882 jjtc000 = false;
7883 } else {
7884 jjtree.popNode();
7885 }
7886 if (jjte000 instanceof RuntimeException) {
7887 {if (true) throw (RuntimeException)jjte000;}
7888 }
7889 if (jjte000 instanceof ParseException) {
7890 {if (true) throw (ParseException)jjte000;}
7891 }
7892 {if (true) throw (Error)jjte000;}
7893 } finally {
7894 if (jjtc000) {
7895 jjtree.closeNodeScope(jjtn000, true);
7896 }
7897 }
7898 throw new Error("Missing return statement in function");
7899 }
7900
7901 final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7902
7903 ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7904 boolean jjtc000 = true;
7905 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7906 StringBuilder name = new StringBuilder();
7907 PLSQLNode characterSet = null;
7908 try {
7909 switch (jj_nt.kind) {
7910 case BFILE_BASE:
7911 jj_consume_token(BFILE_BASE);
7912 break;
7913 case BLOB_BASE:
7914 jj_consume_token(BLOB_BASE);
7915 break;
7916 case CHAR_BASE:
7917 jj_consume_token(CHAR_BASE);
7918 break;
7919 case CLOB_BASE:
7920 jj_consume_token(CLOB_BASE);
7921 break;
7922 case DATE_BASE:
7923 jj_consume_token(DATE_BASE);
7924 break;
7925 case NUMBER_BASE:
7926 jj_consume_token(NUMBER_BASE);
7927 break;
7928 case BINARY_INTEGER:
7929 jj_consume_token(BINARY_INTEGER);
7930 break;
7931 case DEC:
7932 jj_consume_token(DEC);
7933 break;
7934 case DECIMAL:
7935 jj_consume_token(DECIMAL);
7936 break;
7937 case DOUBLE:
7938 jj_consume_token(DOUBLE);
7939 jj_consume_token(PRECISION);
7940 name.append("DOUBLE PRECISION");
7941 break;
7942 case FLOAT:
7943 jj_consume_token(FLOAT);
7944 break;
7945 case INT:
7946 jj_consume_token(INT);
7947 break;
7948 case INTEGER:
7949 jj_consume_token(INTEGER);
7950 break;
7951 case NATURAL:
7952 jj_consume_token(NATURAL);
7953 break;
7954 case NATURALN:
7955 jj_consume_token(NATURALN);
7956 break;
7957 case NUMBER:
7958 jj_consume_token(NUMBER);
7959 break;
7960 case NUMERIC:
7961 jj_consume_token(NUMERIC);
7962 break;
7963 case PLS_INTEGER:
7964 jj_consume_token(PLS_INTEGER);
7965 break;
7966 case POSITIVE:
7967 jj_consume_token(POSITIVE);
7968 break;
7969 case POSITIVEN:
7970 jj_consume_token(POSITIVEN);
7971 break;
7972 case REAL:
7973 jj_consume_token(REAL);
7974 break;
7975 case SIGNTYPE:
7976 jj_consume_token(SIGNTYPE);
7977 break;
7978 case SMALLINT:
7979 jj_consume_token(SMALLINT);
7980 break;
7981 case CHAR:
7982 case LONG:
7983 case RAW:
7984 case ROWID:
7985 case VARCHAR:
7986 case VARCHAR2:
7987 case NCHAR:
7988 case NVARCHAR2:
7989 case STRING:
7990 case UROWID:
7991 case CLOB:
7992 case NCLOB:
7993 case CHARACTER:
7994 switch (jj_nt.kind) {
7995 case CHAR:
7996 jj_consume_token(CHAR);
7997 break;
7998 case CHARACTER:
7999 jj_consume_token(CHARACTER);
8000 break;
8001 default:
8002 jj_la1[98] = jj_gen;
8003 if (jj_2_30(2)) {
8004 jj_consume_token(LONG);
8005 jj_consume_token(RAW);
8006 name.append("LONG RAW");
8007 } else {
8008 switch (jj_nt.kind) {
8009 case LONG:
8010 jj_consume_token(LONG);
8011 break;
8012 case NCHAR:
8013 jj_consume_token(NCHAR);
8014 break;
8015 case NVARCHAR2:
8016 jj_consume_token(NVARCHAR2);
8017 break;
8018 case RAW:
8019 jj_consume_token(RAW);
8020 break;
8021 case ROWID:
8022 jj_consume_token(ROWID);
8023 break;
8024 case STRING:
8025 jj_consume_token(STRING);
8026 break;
8027 case UROWID:
8028 jj_consume_token(UROWID);
8029 break;
8030 case VARCHAR:
8031 jj_consume_token(VARCHAR);
8032 break;
8033 case VARCHAR2:
8034 jj_consume_token(VARCHAR2);
8035 break;
8036 case CLOB:
8037 jj_consume_token(CLOB);
8038 break;
8039 case NCLOB:
8040 jj_consume_token(NCLOB);
8041 break;
8042 default:
8043 jj_la1[99] = jj_gen;
8044 jj_consume_token(-1);
8045 throw new ParseException();
8046 }
8047 }
8048 }
8049 break;
8050 case BOOLEAN:
8051 jj_consume_token(BOOLEAN);
8052 break;
8053 case BFILE:
8054 jj_consume_token(BFILE);
8055 break;
8056 case BLOB:
8057 jj_consume_token(BLOB);
8058 break;
8059 case SYS_REFCURSOR:
8060 jj_consume_token(SYS_REFCURSOR);
8061 break;
8062 case REF:
8063 jj_consume_token(REF);
8064 jj_consume_token(CURSOR);
8065 name.append("REF CURSOR");
8066 break;
8067 case DATE:
8068 jj_consume_token(DATE);
8069 break;
8070 default:
8071 jj_la1[100] = jj_gen;
8072 if (jj_2_31(2)) {
8073 jj_consume_token(INTERVAL);
8074 jj_consume_token(YEAR);
8075 name.append("INTERVAL YEAR");
8076 } else if (jj_2_32(2)) {
8077 jj_consume_token(INTERVAL);
8078 jj_consume_token(DAY);
8079 name.append("INTERVAL DAY");
8080 } else {
8081 switch (jj_nt.kind) {
8082 case TIME:
8083 jj_consume_token(TIME);
8084 break;
8085 case TIMESTAMP:
8086 jj_consume_token(TIMESTAMP);
8087 break;
8088 case SELF:
8089 jj_consume_token(SELF);
8090 jj_consume_token(AS);
8091 jj_consume_token(RESULT);
8092 name.append("SELF AS RESULT");
8093 break;
8094 default:
8095 jj_la1[101] = jj_gen;
8096 jj_consume_token(-1);
8097 throw new ParseException();
8098 }
8099 }
8100 }
8101 if (name.length() == 0 ) {
8102 name.append(token.toString());
8103 }
8104 if (jj_2_33(2)) {
8105 jj_consume_token(5);
8106 size = NumericLiteral();
8107 name.append("("); name.append(size.getImage()) ;
8108 switch (jj_nt.kind) {
8109 case 6:
8110 jj_consume_token(6);
8111 precision = UnaryExpression(true);
8112 name.append(",") ; name.append(precision.getImage()) ;
8113 break;
8114 default:
8115 jj_la1[102] = jj_gen;
8116 ;
8117 }
8118 switch (jj_nt.kind) {
8119 case CHAR:
8120 jj_consume_token(CHAR);
8121 name.append(" CHAR") ;
8122 break;
8123 default:
8124 jj_la1[103] = jj_gen;
8125 ;
8126 }
8127 switch (jj_nt.kind) {
8128 case BYTE:
8129 jj_consume_token(BYTE);
8130 name.append(" BYTE") ;
8131 break;
8132 default:
8133 jj_la1[104] = jj_gen;
8134 ;
8135 }
8136 jj_consume_token(7);
8137 name.append( ")") ;
8138 } else {
8139 ;
8140 }
8141 switch (jj_nt.kind) {
8142 case TO:
8143 case WITH:
8144 case CHARACTER:
8145 switch (jj_nt.kind) {
8146 case CHARACTER:
8147 jj_consume_token(CHARACTER);
8148 jj_consume_token(SET);
8149 characterSet = Name();
8150 name.append( " CHARACTER SET ") ; name.append(characterSet.getImage()) ;
8151 break;
8152 default:
8153 jj_la1[105] = jj_gen;
8154 if (jj_2_35(4)) {
8155 jj_consume_token(WITH);
8156 jj_consume_token(LOCAL);
8157 jj_consume_token(TIME);
8158 jj_consume_token(ZONE);
8159 name.append(" WITH LOCAL TIME ZONE");
8160 } else if (jj_2_36(3)) {
8161 jj_consume_token(WITH);
8162 jj_consume_token(TIME);
8163 jj_consume_token(ZONE);
8164 name.append( " WITH TIME ZONE");
8165 } else if (jj_2_37(2)) {
8166 jj_consume_token(TO);
8167 jj_consume_token(MONTH);
8168 name.append( " TO MONTH");
8169 } else if (jj_2_38(2)) {
8170 jj_consume_token(TO);
8171 jj_consume_token(SECOND);
8172 name.append( " TO SECOND");
8173 if (jj_2_34(2)) {
8174 jj_consume_token(5);
8175 precision = NumericLiteral();
8176 name.append( "(" + precision) ;
8177 jj_consume_token(7);
8178 name.append( ")");
8179 } else {
8180 ;
8181 }
8182 } else {
8183 jj_consume_token(-1);
8184 throw new ParseException();
8185 }
8186 }
8187 break;
8188 default:
8189 jj_la1[106] = jj_gen;
8190 ;
8191 }
8192 jjtree.closeNodeScope(jjtn000, true);
8193 jjtc000 = false;
8194 jjtn000.setImage(name.toString()) ; {if (true) return jjtn000;}
8195 } catch (Throwable jjte000) {
8196 if (jjtc000) {
8197 jjtree.clearNodeScope(jjtn000);
8198 jjtc000 = false;
8199 } else {
8200 jjtree.popNode();
8201 }
8202 if (jjte000 instanceof RuntimeException) {
8203 {if (true) throw (RuntimeException)jjte000;}
8204 }
8205 if (jjte000 instanceof ParseException) {
8206 {if (true) throw (ParseException)jjte000;}
8207 }
8208 {if (true) throw (Error)jjte000;}
8209 } finally {
8210 if (jjtc000) {
8211 jjtree.closeNodeScope(jjtn000, true);
8212 }
8213 }
8214 throw new Error("Missing return statement in function");
8215 }
8216
8217 final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8218
8219 ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8220 boolean jjtc000 = true;
8221 jjtree.openNodeScope(jjtn000);Token t = null ;
8222 PLSQLNode simpleNode = null ;
8223 StringBuilder sb = new StringBuilder() ;
8224 try {
8225 switch (jj_nt.kind) {
8226 case INTERVAL:
8227 jj_consume_token(INTERVAL);
8228 break;
8229 case TIMESTAMP:
8230 jj_consume_token(TIMESTAMP);
8231 break;
8232 case DATE:
8233 jj_consume_token(DATE);
8234 break;
8235 default:
8236 jj_la1[107] = jj_gen;
8237 jj_consume_token(-1);
8238 throw new ParseException();
8239 }
8240 sb.append(token.image);
8241 switch (jj_nt.kind) {
8242 case CHARACTER_LITERAL:
8243 jj_consume_token(CHARACTER_LITERAL);
8244 sb.append(" "); sb.append(token.image);
8245 break;
8246 case STRING_LITERAL:
8247 simpleNode = StringLiteral();
8248 sb.append(" "); sb.append(simpleNode.getImage());
8249 break;
8250 default:
8251 jj_la1[108] = jj_gen;
8252 jj_consume_token(-1);
8253 throw new ParseException();
8254 }
8255 switch (jj_nt.kind) {
8256 case DAY:
8257 case HOUR:
8258 case MINUTE:
8259 case MONTH:
8260 case SECOND:
8261 case YEAR:
8262 switch (jj_nt.kind) {
8263 case YEAR:
8264 jj_consume_token(YEAR);
8265 break;
8266 case MONTH:
8267 jj_consume_token(MONTH);
8268 break;
8269 case DAY:
8270 jj_consume_token(DAY);
8271 break;
8272 case HOUR:
8273 jj_consume_token(HOUR);
8274 break;
8275 case MINUTE:
8276 jj_consume_token(MINUTE);
8277 break;
8278 case SECOND:
8279 jj_consume_token(SECOND);
8280 break;
8281 default:
8282 jj_la1[109] = jj_gen;
8283 jj_consume_token(-1);
8284 throw new ParseException();
8285 }
8286 break;
8287 default:
8288 jj_la1[110] = jj_gen;
8289 ;
8290 }
8291 if (null != t)
8292 {
8293 sb.append(" "); sb.append(token.image);
8294 t = null;
8295 }
8296 if (jj_2_39(2)) {
8297 jj_consume_token(5);
8298 simpleNode = NumericLiteral();
8299 sb.append("("); sb.append(simpleNode.getImage());
8300 jj_consume_token(7);
8301 sb.append("}");
8302 } else {
8303 ;
8304 }
8305 switch (jj_nt.kind) {
8306 case TO:
8307 case WITH:
8308 switch (jj_nt.kind) {
8309 case WITH:
8310 jj_consume_token(WITH);
8311 sb.append(" "); sb.append(token.toString()) ;
8312 switch (jj_nt.kind) {
8313 case LOCAL:
8314 jj_consume_token(LOCAL);
8315 sb.append(" "); sb.append(token.toString()) ;
8316 break;
8317 default:
8318 jj_la1[111] = jj_gen;
8319 ;
8320 }
8321 jj_consume_token(TIME);
8322 jj_consume_token(ZONE);
8323 sb.append(" "); sb.append("TIME ZONE") ;
8324 break;
8325 case TO:
8326 jj_consume_token(TO);
8327 sb.append(" "); sb.append(token.toString()) ;
8328 switch (jj_nt.kind) {
8329 case YEAR:
8330 jj_consume_token(YEAR);
8331 break;
8332 case MONTH:
8333 jj_consume_token(MONTH);
8334 break;
8335 case DAY:
8336 jj_consume_token(DAY);
8337 break;
8338 case HOUR:
8339 jj_consume_token(HOUR);
8340 break;
8341 case MINUTE:
8342 jj_consume_token(MINUTE);
8343 break;
8344 case SECOND:
8345 jj_consume_token(SECOND);
8346 break;
8347 default:
8348 jj_la1[112] = jj_gen;
8349 jj_consume_token(-1);
8350 throw new ParseException();
8351 }
8352 sb.append(token.image);
8353 if (jj_2_40(2)) {
8354 jj_consume_token(5);
8355 simpleNode = NumericLiteral();
8356 sb.append("("); sb.append(simpleNode.getImage());
8357 jj_consume_token(7);
8358 sb.append("}");
8359 } else {
8360 ;
8361 }
8362 break;
8363 default:
8364 jj_la1[113] = jj_gen;
8365 jj_consume_token(-1);
8366 throw new ParseException();
8367 }
8368 break;
8369 default:
8370 jj_la1[114] = jj_gen;
8371 ;
8372 }
8373 jjtree.closeNodeScope(jjtn000, true);
8374 jjtc000 = false;
8375 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
8376 } catch (Throwable jjte000) {
8377 if (jjtc000) {
8378 jjtree.clearNodeScope(jjtn000);
8379 jjtc000 = false;
8380 } else {
8381 jjtree.popNode();
8382 }
8383 if (jjte000 instanceof RuntimeException) {
8384 {if (true) throw (RuntimeException)jjte000;}
8385 }
8386 if (jjte000 instanceof ParseException) {
8387 {if (true) throw (ParseException)jjte000;}
8388 }
8389 {if (true) throw (Error)jjte000;}
8390 } finally {
8391 if (jjtc000) {
8392 jjtree.closeNodeScope(jjtn000, true);
8393 }
8394 }
8395 throw new Error("Missing return statement in function");
8396 }
8397
8398 final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8399
8400 ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8401 boolean jjtc000 = true;
8402 jjtree.openNodeScope(jjtn000);
8403 try {
8404 jj_consume_token(EXCEPTION);
8405 label_20:
8406 while (true) {
8407 if (jj_2_41(2)) {
8408 ;
8409 } else {
8410 break label_20;
8411 }
8412 jj_consume_token(WHEN);
8413 QualifiedName();
8414 label_21:
8415 while (true) {
8416 switch (jj_nt.kind) {
8417 case OR:
8418 ;
8419 break;
8420 default:
8421 jj_la1[115] = jj_gen;
8422 break label_21;
8423 }
8424 jj_consume_token(OR);
8425 QualifiedName();
8426 }
8427 jj_consume_token(THEN);
8428 label_22:
8429 while (true) {
8430 Statement();
8431 switch (jj_nt.kind) {
8432 case 5:
8433 case 16:
8434 case 17:
8435 case 21:
8436 case REPLACE:
8437 case DEFINER:
8438 case CURRENT_USER:
8439 case LANGUAGE:
8440 case INLINE:
8441 case ADD:
8442 case AGGREGATE:
8443 case ARRAY:
8444 case AT:
8445 case ATTRIBUTE:
8446 case AUTHID:
8447 case BEGIN:
8448 case BODY:
8449 case BULK:
8450 case BYTE:
8451 case CASCADE:
8452 case CASE:
8453 case CLOSE:
8454 case COALESCE:
8455 case COLLECT:
8456 case COLUMN:
8457 case COMMENT:
8458 case COMMIT:
8459 case CONSTRUCTOR:
8460 case CONTINUE:
8461 case CONVERT:
8462 case CURRENT:
8463 case CURSOR:
8464 case DATA:
8465 case DATE:
8466 case DAY:
8467 case DECLARE:
8468 case DELETE:
8469 case DISABLE:
8470 case EDITIONABLE:
8471 case ELEMENT:
8472 case ENABLE:
8473 case ESCAPE:
8474 case EXCEPT:
8475 case EXCEPTIONS:
8476 case EXECUTE:
8477 case EXIT:
8478 case EXTERNAL:
8479 case EXTENDS:
8480 case EXTRACT:
8481 case FALSE:
8482 case FETCH:
8483 case FINAL:
8484 case FOR:
8485 case FORALL:
8486 case FORCE:
8487 case FUNCTION:
8488 case GLOBAL:
8489 case GOTO:
8490 case HASH:
8491 case HEAP:
8492 case HOUR:
8493 case IF:
8494 case IMMEDIATE:
8495 case INDICES:
8496 case INDEXTYPE:
8497 case INDICATOR:
8498 case INSERT:
8499 case INSTANTIABLE:
8500 case INTERVAL:
8501 case INVALIDATE:
8502 case ISOLATION:
8503 case JAVA:
8504 case LEVEL:
8505 case LIMIT:
8506 case LOCK:
8507 case LOOP:
8508 case MAP:
8509 case MAX:
8510 case MEMBER:
8511 case MERGE:
8512 case MIN:
8513 case MINUTE:
8514 case MLSLABEL:
8515 case MODIFY:
8516 case MOD:
8517 case MONTH:
8518 case NATURAL:
8519 case NEW:
8520 case NEW_DOT:
8521 case NO:
8522 case NONEDITIONABLE:
8523 case NOT:
8524 case NULL:
8525 case NULLIF:
8526 case OBJECT:
8527 case OID:
8528 case OPAQUE:
8529 case OPEN:
8530 case OPERATOR:
8531 case ORGANIZATION:
8532 case OTHERS:
8533 case OVERRIDING:
8534 case PACKAGE:
8535 case PARTITION:
8536 case PIPE:
8537 case PRAGMA:
8538 case PRESERVE:
8539 case PRIVATE:
8540 case PROCEDURE:
8541 case RAISE:
8542 case RANGE:
8543 case RAW:
8544 case REAL:
8545 case RECORD:
8546 case REF:
8547 case RELEASE:
8548 case RELIES_ON:
8549 case RENAME:
8550 case RESULT:
8551 case RETURN:
8552 case RETURNING:
8553 case REVERSE:
8554 case ROLLBACK:
8555 case ROW:
8556 case ROWS:
8557 case ROWID:
8558 case ROWNUM:
8559 case SAVE:
8560 case SAVEPOINT:
8561 case SECOND:
8562 case SELECT:
8563 case SELF:
8564 case SET:
8565 case SPACE:
8566 case SQL:
8567 case SQLCODE:
8568 case SQLERRM:
8569 case STATIC:
8570 case SUBTYPE:
8571 case SUBSTITUTABLE:
8572 case SUCCESSFUL:
8573 case SYSDATE:
8574 case SYS_REFCURSOR:
8575 case TEMPORARY:
8576 case TIME:
8577 case TIMESTAMP:
8578 case TIMEZONE_REGION:
8579 case TIMEZONE_ABBR:
8580 case TIMEZONE_MINUTE:
8581 case TIMEZONE_HOUR:
8582 case TRANSACTION:
8583 case TRUE:
8584 case TYPE:
8585 case UNDER:
8586 case USING:
8587 case WHILE:
8588 case YES:
8589 case SHOW:
8590 case A:
8591 case UPDATE:
8592 case DOUBLE:
8593 case DEC:
8594 case PRECISION:
8595 case INT:
8596 case NUMERIC:
8597 case NCHAR:
8598 case NVARCHAR2:
8599 case STRING:
8600 case UROWID:
8601 case VARRAY:
8602 case VARYING:
8603 case BFILE:
8604 case BLOB:
8605 case CLOB:
8606 case NCLOB:
8607 case YEAR:
8608 case LOCAL:
8609 case WITH:
8610 case ZONE:
8611 case CHARACTER:
8612 case AFTER:
8613 case BEFORE:
8614 case OLD:
8615 case PARENT:
8616 case CC_IF:
8617 case CC_ERROR:
8618 case ANALYZE:
8619 case ASSOCIATE:
8620 case AUDIT:
8621 case COMPOUND:
8622 case DATABASE:
8623 case CALL:
8624 case DDL:
8625 case DISASSOCIATE:
8626 case EACH:
8627 case FOLLOWS:
8628 case LOGOFF:
8629 case LOGON:
8630 case NESTED:
8631 case NOAUDIT:
8632 case SCHEMA:
8633 case SERVERERROR:
8634 case SHUTDOWN:
8635 case STARTUP:
8636 case STATEMENT:
8637 case STATISTICS:
8638 case SUSPEND:
8639 case TRUNCATE:
8640 case WRAPPED:
8641 case LIBRARY:
8642 case NAME:
8643 case STRUCT:
8644 case CONTEXT:
8645 case PARAMETERS:
8646 case LENGTH:
8647 case TDO:
8648 case MAXLEN:
8649 case CHARSETID:
8650 case CHARSETFORM:
8651 case ACCEPT:
8652 case ACCESSIBLE:
8653 case COPY:
8654 case DEFINE:
8655 case DISCONNECT:
8656 case HOST:
8657 case PRINT:
8658 case QUIT:
8659 case REMARK:
8660 case UNDEFINE:
8661 case VARIABLE:
8662 case WHENEVER:
8663 case ATTACH:
8664 case CAST:
8665 case TREAT:
8666 case TRIM:
8667 case LEFT:
8668 case RIGHT:
8669 case BOTH:
8670 case EMPTY:
8671 case MULTISET:
8672 case SUBMULTISET:
8673 case LEADING:
8674 case TRAILING:
8675 case CHAR_CS:
8676 case NCHAR_CS:
8677 case DBTIMEZONE:
8678 case SESSIONTIMEZONE:
8679 case AUTHENTICATED:
8680 case LINK:
8681 case SHARED:
8682 case DIRECTORY:
8683 case USER:
8684 case IDENTIFIER:
8685 case UNSIGNED_NUMERIC_LITERAL:
8686 case CHARACTER_LITERAL:
8687 case STRING_LITERAL:
8688 case QUOTED_LITERAL:
8689 ;
8690 break;
8691 default:
8692 jj_la1[116] = jj_gen;
8693 break label_22;
8694 }
8695 }
8696 }
8697 switch (jj_nt.kind) {
8698 case WHEN:
8699 jj_consume_token(WHEN);
8700 jj_consume_token(OTHERS);
8701 jj_consume_token(THEN);
8702 label_23:
8703 while (true) {
8704 Statement();
8705 switch (jj_nt.kind) {
8706 case 5:
8707 case 16:
8708 case 17:
8709 case 21:
8710 case REPLACE:
8711 case DEFINER:
8712 case CURRENT_USER:
8713 case LANGUAGE:
8714 case INLINE:
8715 case ADD:
8716 case AGGREGATE:
8717 case ARRAY:
8718 case AT:
8719 case ATTRIBUTE:
8720 case AUTHID:
8721 case BEGIN:
8722 case BODY:
8723 case BULK:
8724 case BYTE:
8725 case CASCADE:
8726 case CASE:
8727 case CLOSE:
8728 case COALESCE:
8729 case COLLECT:
8730 case COLUMN:
8731 case COMMENT:
8732 case COMMIT:
8733 case CONSTRUCTOR:
8734 case CONTINUE:
8735 case CONVERT:
8736 case CURRENT:
8737 case CURSOR:
8738 case DATA:
8739 case DATE:
8740 case DAY:
8741 case DECLARE:
8742 case DELETE:
8743 case DISABLE:
8744 case EDITIONABLE:
8745 case ELEMENT:
8746 case ENABLE:
8747 case ESCAPE:
8748 case EXCEPT:
8749 case EXCEPTIONS:
8750 case EXECUTE:
8751 case EXIT:
8752 case EXTERNAL:
8753 case EXTENDS:
8754 case EXTRACT:
8755 case FALSE:
8756 case FETCH:
8757 case FINAL:
8758 case FOR:
8759 case FORALL:
8760 case FORCE:
8761 case FUNCTION:
8762 case GLOBAL:
8763 case GOTO:
8764 case HASH:
8765 case HEAP:
8766 case HOUR:
8767 case IF:
8768 case IMMEDIATE:
8769 case INDICES:
8770 case INDEXTYPE:
8771 case INDICATOR:
8772 case INSERT:
8773 case INSTANTIABLE:
8774 case INTERVAL:
8775 case INVALIDATE:
8776 case ISOLATION:
8777 case JAVA:
8778 case LEVEL:
8779 case LIMIT:
8780 case LOCK:
8781 case LOOP:
8782 case MAP:
8783 case MAX:
8784 case MEMBER:
8785 case MERGE:
8786 case MIN:
8787 case MINUTE:
8788 case MLSLABEL:
8789 case MODIFY:
8790 case MOD:
8791 case MONTH:
8792 case NATURAL:
8793 case NEW:
8794 case NEW_DOT:
8795 case NO:
8796 case NONEDITIONABLE:
8797 case NOT:
8798 case NULL:
8799 case NULLIF:
8800 case OBJECT:
8801 case OID:
8802 case OPAQUE:
8803 case OPEN:
8804 case OPERATOR:
8805 case ORGANIZATION:
8806 case OTHERS:
8807 case OVERRIDING:
8808 case PACKAGE:
8809 case PARTITION:
8810 case PIPE:
8811 case PRAGMA:
8812 case PRESERVE:
8813 case PRIVATE:
8814 case PROCEDURE:
8815 case RAISE:
8816 case RANGE:
8817 case RAW:
8818 case REAL:
8819 case RECORD:
8820 case REF:
8821 case RELEASE:
8822 case RELIES_ON:
8823 case RENAME:
8824 case RESULT:
8825 case RETURN:
8826 case RETURNING:
8827 case REVERSE:
8828 case ROLLBACK:
8829 case ROW:
8830 case ROWS:
8831 case ROWID:
8832 case ROWNUM:
8833 case SAVE:
8834 case SAVEPOINT:
8835 case SECOND:
8836 case SELECT:
8837 case SELF:
8838 case SET:
8839 case SPACE:
8840 case SQL:
8841 case SQLCODE:
8842 case SQLERRM:
8843 case STATIC:
8844 case SUBTYPE:
8845 case SUBSTITUTABLE:
8846 case SUCCESSFUL:
8847 case SYSDATE:
8848 case SYS_REFCURSOR:
8849 case TEMPORARY:
8850 case TIME:
8851 case TIMESTAMP:
8852 case TIMEZONE_REGION:
8853 case TIMEZONE_ABBR:
8854 case TIMEZONE_MINUTE:
8855 case TIMEZONE_HOUR:
8856 case TRANSACTION:
8857 case TRUE:
8858 case TYPE:
8859 case UNDER:
8860 case USING:
8861 case WHILE:
8862 case YES:
8863 case SHOW:
8864 case A:
8865 case UPDATE:
8866 case DOUBLE:
8867 case DEC:
8868 case PRECISION:
8869 case INT:
8870 case NUMERIC:
8871 case NCHAR:
8872 case NVARCHAR2:
8873 case STRING:
8874 case UROWID:
8875 case VARRAY:
8876 case VARYING:
8877 case BFILE:
8878 case BLOB:
8879 case CLOB:
8880 case NCLOB:
8881 case YEAR:
8882 case LOCAL:
8883 case WITH:
8884 case ZONE:
8885 case CHARACTER:
8886 case AFTER:
8887 case BEFORE:
8888 case OLD:
8889 case PARENT:
8890 case CC_IF:
8891 case CC_ERROR:
8892 case ANALYZE:
8893 case ASSOCIATE:
8894 case AUDIT:
8895 case COMPOUND:
8896 case DATABASE:
8897 case CALL:
8898 case DDL:
8899 case DISASSOCIATE:
8900 case EACH:
8901 case FOLLOWS:
8902 case LOGOFF:
8903 case LOGON:
8904 case NESTED:
8905 case NOAUDIT:
8906 case SCHEMA:
8907 case SERVERERROR:
8908 case SHUTDOWN:
8909 case STARTUP:
8910 case STATEMENT:
8911 case STATISTICS:
8912 case SUSPEND:
8913 case TRUNCATE:
8914 case WRAPPED:
8915 case LIBRARY:
8916 case NAME:
8917 case STRUCT:
8918 case CONTEXT:
8919 case PARAMETERS:
8920 case LENGTH:
8921 case TDO:
8922 case MAXLEN:
8923 case CHARSETID:
8924 case CHARSETFORM:
8925 case ACCEPT:
8926 case ACCESSIBLE:
8927 case COPY:
8928 case DEFINE:
8929 case DISCONNECT:
8930 case HOST:
8931 case PRINT:
8932 case QUIT:
8933 case REMARK:
8934 case UNDEFINE:
8935 case VARIABLE:
8936 case WHENEVER:
8937 case ATTACH:
8938 case CAST:
8939 case TREAT:
8940 case TRIM:
8941 case LEFT:
8942 case RIGHT:
8943 case BOTH:
8944 case EMPTY:
8945 case MULTISET:
8946 case SUBMULTISET:
8947 case LEADING:
8948 case TRAILING:
8949 case CHAR_CS:
8950 case NCHAR_CS:
8951 case DBTIMEZONE:
8952 case SESSIONTIMEZONE:
8953 case AUTHENTICATED:
8954 case LINK:
8955 case SHARED:
8956 case DIRECTORY:
8957 case USER:
8958 case IDENTIFIER:
8959 case UNSIGNED_NUMERIC_LITERAL:
8960 case CHARACTER_LITERAL:
8961 case STRING_LITERAL:
8962 case QUOTED_LITERAL:
8963 ;
8964 break;
8965 default:
8966 jj_la1[117] = jj_gen;
8967 break label_23;
8968 }
8969 }
8970 break;
8971 default:
8972 jj_la1[118] = jj_gen;
8973 ;
8974 }
8975 jjtree.closeNodeScope(jjtn000, true);
8976 jjtc000 = false;
8977 {if (true) return jjtn000 ;}
8978 } catch (Throwable jjte000) {
8979 if (jjtc000) {
8980 jjtree.clearNodeScope(jjtn000);
8981 jjtc000 = false;
8982 } else {
8983 jjtree.popNode();
8984 }
8985 if (jjte000 instanceof RuntimeException) {
8986 {if (true) throw (RuntimeException)jjte000;}
8987 }
8988 if (jjte000 instanceof ParseException) {
8989 {if (true) throw (ParseException)jjte000;}
8990 }
8991 {if (true) throw (Error)jjte000;}
8992 } finally {
8993 if (jjtc000) {
8994 jjtree.closeNodeScope(jjtn000, true);
8995 }
8996 }
8997 throw new Error("Missing return statement in function");
8998 }
8999
9000 final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
9001
9002 ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
9003 boolean jjtc000 = true;
9004 jjtree.openNodeScope(jjtn000);Token beginToken = getToken(0);
9005 Token t = getToken(1);
9006 int count = (initiator == null) ? 0 : 1;
9007 if(t.image.equals(initiator)) count++;
9008 while (count > 0 || !t.image.equals(terminator))
9009 {
9010 t = getNextToken();
9011 t = getToken(1);
9012 if(t.image.equals(initiator)) count++;
9013 if(t.image.equals(terminator)) count--;
9014 if((null != t.specialToken && beginToken.kind != SELECT && beginToken.kind != INSERT && beginToken.kind != UPDATE && beginToken.kind != DELETE && beginToken.kind != MERGE) || t.kind == EOF)
9015 return;
9016 if (t.specialToken != null && "/".equals(t.image))
9017 return;
9018 }
9019 try {
9020 jjtree.closeNodeScope(jjtn000, true);
9021 jjtc000 = false;
9022 {if (true) return;}
9023 } finally {
9024 if (jjtc000) {
9025 jjtree.closeNodeScope(jjtn000, true);
9026 }
9027 }
9028 }
9029
9030
9031
9032
9033 final public void Skip2NextOccurrence(String target) throws ParseException {
9034
9035 ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9036 boolean jjtc000 = true;
9037 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9038 while (!nextToken.image.equals(target)
9039 && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) )
9040 && nextToken.kind!=EOF
9041 )
9042 {
9043 nextToken = getNextToken();
9044 nextToken = getToken(1);
9045 }
9046 try {
9047 jjtree.closeNodeScope(jjtn000, true);
9048 jjtc000 = false;
9049 {if (true) return;}
9050 } finally {
9051 if (jjtc000) {
9052 jjtree.closeNodeScope(jjtn000, true);
9053 }
9054 }
9055 }
9056
9057
9058
9059
9060 final public void SkipPastNextOccurrence(String target) throws ParseException {
9061
9062 ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9063 boolean jjtc000 = true;
9064 jjtree.openNodeScope(jjtn000);Token t = null;
9065 Skip2NextOccurrence(target) ;
9066 t = getNextToken();
9067 try {
9068 jjtree.closeNodeScope(jjtn000, true);
9069 jjtc000 = false;
9070 {if (true) return;}
9071 } finally {
9072 if (jjtc000) {
9073 jjtree.closeNodeScope(jjtn000, true);
9074 }
9075 }
9076 }
9077
9078
9079
9080
9081 final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9082
9083 ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9084 boolean jjtc000 = true;
9085 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9086 Token specToken = null ;
9087 while (nextToken.kind!=target
9088 && (null == nextToken.specialToken || nextToken.specialToken.kind!=target )
9089 && nextToken.kind!=EOF
9090 )
9091 {
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106 specToken = nextToken.specialToken;
9107 if (null!= specToken)
9108 {
9109
9110 while (specToken != null && specToken.kind != target)
9111 {
9112 specToken = specToken.specialToken;
9113 }
9114
9115
9116 if (null != specToken && specToken.kind == target)
9117 {
9118 break;
9119 }
9120 }
9121
9122 nextToken = getNextToken();
9123 nextToken = getToken(1);
9124 }
9125 try {
9126 jjtree.closeNodeScope(jjtn000, true);
9127 jjtc000 = false;
9128 {if (true) return;}
9129 } finally {
9130 if (jjtc000) {
9131 jjtree.closeNodeScope(jjtn000, true);
9132 }
9133 }
9134 }
9135
9136
9137
9138
9139 final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9140
9141 ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9142 boolean jjtc000 = true;
9143 jjtree.openNodeScope(jjtn000);Token t = null;
9144 Skip2NextTokenOccurrence(target) ;
9145 t = getNextToken();
9146 try {
9147 jjtree.closeNodeScope(jjtn000, true);
9148 jjtc000 = false;
9149 {if (true) return;}
9150 } finally {
9151 if (jjtc000) {
9152 jjtree.closeNodeScope(jjtn000, true);
9153 }
9154 }
9155 }
9156
9157
9158
9159
9160 final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9161
9162 ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9163 boolean jjtc000 = true;
9164 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9165 Token nextToken = getToken(1);
9166 while (!nextToken.image.equals(target)
9167 && nextToken.kind!=EOF
9168 )
9169 {
9170 nextToken = getNextToken();
9171 sb.append(nextToken.image);
9172 nextToken = getToken(1);
9173 }
9174 try {
9175 jjtree.closeNodeScope(jjtn000, true);
9176 jjtc000 = false;
9177 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9178 } finally {
9179 if (jjtc000) {
9180 jjtree.closeNodeScope(jjtn000, true);
9181 }
9182 }
9183 throw new Error("Missing return statement in function");
9184 }
9185
9186
9187
9188
9189 final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9190
9191 ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9192 boolean jjtc000 = true;
9193 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9194 Token t = null;
9195 sb.append(Read2NextOccurrence(target)) ;
9196 t = getNextToken();
9197 sb.append(t.image);
9198 try {
9199 jjtree.closeNodeScope(jjtn000, true);
9200 jjtc000 = false;
9201 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9202 } finally {
9203 if (jjtc000) {
9204 jjtree.closeNodeScope(jjtn000, true);
9205 }
9206 }
9207 throw new Error("Missing return statement in function");
9208 }
9209
9210
9211
9212
9213 final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9214
9215 ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9216 boolean jjtc000 = true;
9217 jjtree.openNodeScope(jjtn000);
9218 try {
9219 switch (jj_nt.kind) {
9220 case SELECT:
9221 jj_consume_token(SELECT);
9222 break;
9223 case UPDATE:
9224 jj_consume_token(UPDATE);
9225 break;
9226 case INSERT:
9227 jj_consume_token(INSERT);
9228 break;
9229 case DELETE:
9230 jj_consume_token(DELETE);
9231 break;
9232 case COMMIT:
9233 jj_consume_token(COMMIT);
9234 break;
9235 case ROLLBACK:
9236 jj_consume_token(ROLLBACK);
9237 break;
9238 case SAVEPOINT:
9239 jj_consume_token(SAVEPOINT);
9240 break;
9241 case EXECUTE:
9242 jj_consume_token(EXECUTE);
9243 break;
9244 case SET:
9245 jj_consume_token(SET);
9246 jj_consume_token(TRANSACTION);
9247 break;
9248 case LOCK:
9249 jj_consume_token(LOCK);
9250 jj_consume_token(TABLE);
9251 break;
9252 case MERGE:
9253 jj_consume_token(MERGE);
9254 break;
9255 case WITH:
9256 jj_consume_token(WITH);
9257 break;
9258 default:
9259 jj_la1[119] = jj_gen;
9260 jj_consume_token(-1);
9261 throw new ParseException();
9262 }
9263 Skip2NextTerminator(initiator,terminator);
9264 jjtree.closeNodeScope(jjtn000, true);
9265 jjtc000 = false;
9266 {if (true) return jjtn000 ;}
9267 } catch (Throwable jjte000) {
9268 if (jjtc000) {
9269 jjtree.clearNodeScope(jjtn000);
9270 jjtc000 = false;
9271 } else {
9272 jjtree.popNode();
9273 }
9274 if (jjte000 instanceof RuntimeException) {
9275 {if (true) throw (RuntimeException)jjte000;}
9276 }
9277 if (jjte000 instanceof ParseException) {
9278 {if (true) throw (ParseException)jjte000;}
9279 }
9280 {if (true) throw (Error)jjte000;}
9281 } finally {
9282 if (jjtc000) {
9283 jjtree.closeNodeScope(jjtn000, true);
9284 }
9285 }
9286 throw new Error("Missing return statement in function");
9287 }
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9322
9323
9324
9325 final public void WrappedObject() throws ParseException {
9326
9327 ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9328 boolean jjtc000 = true;
9329 jjtree.openNodeScope(jjtn000);
9330 try {
9331 jj_consume_token(WRAPPED);
9332 jjtree.closeNodeScope(jjtn000, true);
9333 jjtc000 = false;
9334 Token nextToken;
9335
9336 nextToken = getToken(1);
9337 while (
9338 null != nextToken && nextToken.kind!=EOF
9339 )
9340 {
9341 nextToken = getNextToken();
9342
9343
9344 nextToken = getToken(1);
9345 }
9346 {if (true) return;}
9347 } finally {
9348 if (jjtc000) {
9349 jjtree.closeNodeScope(jjtn000, true);
9350 }
9351 }
9352 }
9353
9354
9355
9356
9357
9358
9359
9360
9361 final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9362
9363 ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9364 boolean jjtc000 = true;
9365 jjtree.openNodeScope(jjtn000);
9366 try {
9367 if (jj_2_42(2147483647)) {
9368 SqlStatement(null,";");
9369 switch (jj_nt.kind) {
9370 case 4:
9371 jj_consume_token(4);
9372 break;
9373 default:
9374 jj_la1[120] = jj_gen;
9375 ;
9376 }
9377 } else if (jj_2_43(3)) {
9378 ContinueStatement();
9379 jj_consume_token(4);
9380 } else {
9381 switch (jj_nt.kind) {
9382 case CASE:
9383 CaseStatement();
9384 jj_consume_token(4);
9385 break;
9386 case IF:
9387 IfStatement();
9388 jj_consume_token(4);
9389 break;
9390 case FOR:
9391 ForStatement();
9392 jj_consume_token(4);
9393 break;
9394 case FORALL:
9395 ForAllStatement();
9396 jj_consume_token(4);
9397 break;
9398 case LOOP:
9399 LoopStatement();
9400 jj_consume_token(4);
9401 break;
9402 case WHILE:
9403 WhileStatement();
9404 jj_consume_token(4);
9405 break;
9406 case GOTO:
9407 GotoStatement();
9408 jj_consume_token(4);
9409 break;
9410 case RETURN:
9411 ReturnStatement();
9412 jj_consume_token(4);
9413 break;
9414 case EXIT:
9415 ExitStatement();
9416 jj_consume_token(4);
9417 break;
9418 case RAISE:
9419 RaiseStatement();
9420 jj_consume_token(4);
9421 break;
9422 case CLOSE:
9423 CloseStatement();
9424 jj_consume_token(4);
9425 break;
9426 case OPEN:
9427 OpenStatement();
9428 jj_consume_token(4);
9429 break;
9430 case FETCH:
9431 FetchStatement();
9432 jj_consume_token(4);
9433 break;
9434 case BEGIN:
9435 case DECLARE:
9436 Block();
9437 jj_consume_token(4);
9438 break;
9439 case EXECUTE:
9440 EmbeddedSqlStatement();
9441 jj_consume_token(4);
9442 break;
9443 case PIPE:
9444 PipelineStatement();
9445 jj_consume_token(4);
9446 break;
9447 case CC_IF:
9448 case CC_ERROR:
9449 ConditionalCompilationStatement();
9450 break;
9451 case PRAGMA:
9452 InlinePragma();
9453 jj_consume_token(4);
9454 break;
9455 case 5:
9456 case 16:
9457 case 17:
9458 case REPLACE:
9459 case DEFINER:
9460 case CURRENT_USER:
9461 case LANGUAGE:
9462 case INLINE:
9463 case ADD:
9464 case AGGREGATE:
9465 case ARRAY:
9466 case AT:
9467 case ATTRIBUTE:
9468 case AUTHID:
9469 case BODY:
9470 case BULK:
9471 case BYTE:
9472 case CASCADE:
9473 case COALESCE:
9474 case COLLECT:
9475 case COLUMN:
9476 case COMMENT:
9477 case COMMIT:
9478 case CONSTRUCTOR:
9479 case CONTINUE:
9480 case CONVERT:
9481 case CURRENT:
9482 case CURSOR:
9483 case DATA:
9484 case DATE:
9485 case DAY:
9486 case DISABLE:
9487 case EDITIONABLE:
9488 case ELEMENT:
9489 case ENABLE:
9490 case ESCAPE:
9491 case EXCEPT:
9492 case EXCEPTIONS:
9493 case EXTERNAL:
9494 case EXTENDS:
9495 case EXTRACT:
9496 case FALSE:
9497 case FINAL:
9498 case FORCE:
9499 case FUNCTION:
9500 case GLOBAL:
9501 case HASH:
9502 case HEAP:
9503 case HOUR:
9504 case IMMEDIATE:
9505 case INDICES:
9506 case INDEXTYPE:
9507 case INDICATOR:
9508 case INSTANTIABLE:
9509 case INTERVAL:
9510 case INVALIDATE:
9511 case ISOLATION:
9512 case JAVA:
9513 case LEVEL:
9514 case LIMIT:
9515 case MAP:
9516 case MAX:
9517 case MEMBER:
9518 case MERGE:
9519 case MIN:
9520 case MINUTE:
9521 case MLSLABEL:
9522 case MODIFY:
9523 case MOD:
9524 case MONTH:
9525 case NATURAL:
9526 case NEW:
9527 case NEW_DOT:
9528 case NO:
9529 case NONEDITIONABLE:
9530 case NOT:
9531 case NULL:
9532 case NULLIF:
9533 case OBJECT:
9534 case OID:
9535 case OPAQUE:
9536 case OPERATOR:
9537 case ORGANIZATION:
9538 case OTHERS:
9539 case OVERRIDING:
9540 case PACKAGE:
9541 case PARTITION:
9542 case PRESERVE:
9543 case PRIVATE:
9544 case PROCEDURE:
9545 case RANGE:
9546 case RAW:
9547 case REAL:
9548 case RECORD:
9549 case REF:
9550 case RELEASE:
9551 case RELIES_ON:
9552 case RENAME:
9553 case RESULT:
9554 case RETURNING:
9555 case REVERSE:
9556 case ROLLBACK:
9557 case ROW:
9558 case ROWS:
9559 case ROWID:
9560 case ROWNUM:
9561 case SAVE:
9562 case SAVEPOINT:
9563 case SECOND:
9564 case SELECT:
9565 case SELF:
9566 case SET:
9567 case SPACE:
9568 case SQL:
9569 case SQLCODE:
9570 case SQLERRM:
9571 case STATIC:
9572 case SUBTYPE:
9573 case SUBSTITUTABLE:
9574 case SUCCESSFUL:
9575 case SYSDATE:
9576 case SYS_REFCURSOR:
9577 case TEMPORARY:
9578 case TIME:
9579 case TIMESTAMP:
9580 case TIMEZONE_REGION:
9581 case TIMEZONE_ABBR:
9582 case TIMEZONE_MINUTE:
9583 case TIMEZONE_HOUR:
9584 case TRANSACTION:
9585 case TRUE:
9586 case TYPE:
9587 case UNDER:
9588 case USING:
9589 case YES:
9590 case SHOW:
9591 case A:
9592 case DOUBLE:
9593 case DEC:
9594 case PRECISION:
9595 case INT:
9596 case NUMERIC:
9597 case NCHAR:
9598 case NVARCHAR2:
9599 case STRING:
9600 case UROWID:
9601 case VARRAY:
9602 case VARYING:
9603 case BFILE:
9604 case BLOB:
9605 case CLOB:
9606 case NCLOB:
9607 case YEAR:
9608 case LOCAL:
9609 case WITH:
9610 case ZONE:
9611 case CHARACTER:
9612 case AFTER:
9613 case BEFORE:
9614 case OLD:
9615 case PARENT:
9616 case ANALYZE:
9617 case ASSOCIATE:
9618 case AUDIT:
9619 case COMPOUND:
9620 case DATABASE:
9621 case CALL:
9622 case DDL:
9623 case DISASSOCIATE:
9624 case EACH:
9625 case FOLLOWS:
9626 case LOGOFF:
9627 case LOGON:
9628 case NESTED:
9629 case NOAUDIT:
9630 case SCHEMA:
9631 case SERVERERROR:
9632 case SHUTDOWN:
9633 case STARTUP:
9634 case STATEMENT:
9635 case STATISTICS:
9636 case SUSPEND:
9637 case TRUNCATE:
9638 case WRAPPED:
9639 case LIBRARY:
9640 case NAME:
9641 case STRUCT:
9642 case CONTEXT:
9643 case PARAMETERS:
9644 case LENGTH:
9645 case TDO:
9646 case MAXLEN:
9647 case CHARSETID:
9648 case CHARSETFORM:
9649 case ACCEPT:
9650 case ACCESSIBLE:
9651 case COPY:
9652 case DEFINE:
9653 case DISCONNECT:
9654 case HOST:
9655 case PRINT:
9656 case QUIT:
9657 case REMARK:
9658 case UNDEFINE:
9659 case VARIABLE:
9660 case WHENEVER:
9661 case ATTACH:
9662 case CAST:
9663 case TREAT:
9664 case TRIM:
9665 case LEFT:
9666 case RIGHT:
9667 case BOTH:
9668 case EMPTY:
9669 case MULTISET:
9670 case SUBMULTISET:
9671 case LEADING:
9672 case TRAILING:
9673 case CHAR_CS:
9674 case NCHAR_CS:
9675 case DBTIMEZONE:
9676 case SESSIONTIMEZONE:
9677 case AUTHENTICATED:
9678 case LINK:
9679 case SHARED:
9680 case DIRECTORY:
9681 case USER:
9682 case IDENTIFIER:
9683 case UNSIGNED_NUMERIC_LITERAL:
9684 case CHARACTER_LITERAL:
9685 case STRING_LITERAL:
9686 case QUOTED_LITERAL:
9687 Expression();
9688 jj_consume_token(4);
9689 break;
9690 default:
9691 jj_la1[121] = jj_gen;
9692 jj_consume_token(-1);
9693 throw new ParseException();
9694 }
9695 }
9696 jjtree.closeNodeScope(jjtn000, true);
9697 jjtc000 = false;
9698 {if (true) return jjtn000 ;}
9699 } catch (Throwable jjte000) {
9700 if (jjtc000) {
9701 jjtree.clearNodeScope(jjtn000);
9702 jjtc000 = false;
9703 } else {
9704 jjtree.popNode();
9705 }
9706 if (jjte000 instanceof RuntimeException) {
9707 {if (true) throw (RuntimeException)jjte000;}
9708 }
9709 if (jjte000 instanceof ParseException) {
9710 {if (true) throw (ParseException)jjte000;}
9711 }
9712 {if (true) throw (Error)jjte000;}
9713 } finally {
9714 if (jjtc000) {
9715 jjtree.closeNodeScope(jjtn000, true);
9716 }
9717 }
9718 throw new Error("Missing return statement in function");
9719 }
9720
9721 final public ASTStatement Statement() throws ParseException {
9722
9723 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9724 boolean jjtc000 = true;
9725 jjtree.openNodeScope(jjtn000);
9726 try {
9727 switch (jj_nt.kind) {
9728 case 21:
9729 LabelledStatement();
9730 break;
9731 case 5:
9732 case 16:
9733 case 17:
9734 case REPLACE:
9735 case DEFINER:
9736 case CURRENT_USER:
9737 case LANGUAGE:
9738 case INLINE:
9739 case ADD:
9740 case AGGREGATE:
9741 case ARRAY:
9742 case AT:
9743 case ATTRIBUTE:
9744 case AUTHID:
9745 case BEGIN:
9746 case BODY:
9747 case BULK:
9748 case BYTE:
9749 case CASCADE:
9750 case CASE:
9751 case CLOSE:
9752 case COALESCE:
9753 case COLLECT:
9754 case COLUMN:
9755 case COMMENT:
9756 case COMMIT:
9757 case CONSTRUCTOR:
9758 case CONTINUE:
9759 case CONVERT:
9760 case CURRENT:
9761 case CURSOR:
9762 case DATA:
9763 case DATE:
9764 case DAY:
9765 case DECLARE:
9766 case DELETE:
9767 case DISABLE:
9768 case EDITIONABLE:
9769 case ELEMENT:
9770 case ENABLE:
9771 case ESCAPE:
9772 case EXCEPT:
9773 case EXCEPTIONS:
9774 case EXECUTE:
9775 case EXIT:
9776 case EXTERNAL:
9777 case EXTENDS:
9778 case EXTRACT:
9779 case FALSE:
9780 case FETCH:
9781 case FINAL:
9782 case FOR:
9783 case FORALL:
9784 case FORCE:
9785 case FUNCTION:
9786 case GLOBAL:
9787 case GOTO:
9788 case HASH:
9789 case HEAP:
9790 case HOUR:
9791 case IF:
9792 case IMMEDIATE:
9793 case INDICES:
9794 case INDEXTYPE:
9795 case INDICATOR:
9796 case INSERT:
9797 case INSTANTIABLE:
9798 case INTERVAL:
9799 case INVALIDATE:
9800 case ISOLATION:
9801 case JAVA:
9802 case LEVEL:
9803 case LIMIT:
9804 case LOCK:
9805 case LOOP:
9806 case MAP:
9807 case MAX:
9808 case MEMBER:
9809 case MERGE:
9810 case MIN:
9811 case MINUTE:
9812 case MLSLABEL:
9813 case MODIFY:
9814 case MOD:
9815 case MONTH:
9816 case NATURAL:
9817 case NEW:
9818 case NEW_DOT:
9819 case NO:
9820 case NONEDITIONABLE:
9821 case NOT:
9822 case NULL:
9823 case NULLIF:
9824 case OBJECT:
9825 case OID:
9826 case OPAQUE:
9827 case OPEN:
9828 case OPERATOR:
9829 case ORGANIZATION:
9830 case OTHERS:
9831 case OVERRIDING:
9832 case PACKAGE:
9833 case PARTITION:
9834 case PIPE:
9835 case PRAGMA:
9836 case PRESERVE:
9837 case PRIVATE:
9838 case PROCEDURE:
9839 case RAISE:
9840 case RANGE:
9841 case RAW:
9842 case REAL:
9843 case RECORD:
9844 case REF:
9845 case RELEASE:
9846 case RELIES_ON:
9847 case RENAME:
9848 case RESULT:
9849 case RETURN:
9850 case RETURNING:
9851 case REVERSE:
9852 case ROLLBACK:
9853 case ROW:
9854 case ROWS:
9855 case ROWID:
9856 case ROWNUM:
9857 case SAVE:
9858 case SAVEPOINT:
9859 case SECOND:
9860 case SELECT:
9861 case SELF:
9862 case SET:
9863 case SPACE:
9864 case SQL:
9865 case SQLCODE:
9866 case SQLERRM:
9867 case STATIC:
9868 case SUBTYPE:
9869 case SUBSTITUTABLE:
9870 case SUCCESSFUL:
9871 case SYSDATE:
9872 case SYS_REFCURSOR:
9873 case TEMPORARY:
9874 case TIME:
9875 case TIMESTAMP:
9876 case TIMEZONE_REGION:
9877 case TIMEZONE_ABBR:
9878 case TIMEZONE_MINUTE:
9879 case TIMEZONE_HOUR:
9880 case TRANSACTION:
9881 case TRUE:
9882 case TYPE:
9883 case UNDER:
9884 case USING:
9885 case WHILE:
9886 case YES:
9887 case SHOW:
9888 case A:
9889 case UPDATE:
9890 case DOUBLE:
9891 case DEC:
9892 case PRECISION:
9893 case INT:
9894 case NUMERIC:
9895 case NCHAR:
9896 case NVARCHAR2:
9897 case STRING:
9898 case UROWID:
9899 case VARRAY:
9900 case VARYING:
9901 case BFILE:
9902 case BLOB:
9903 case CLOB:
9904 case NCLOB:
9905 case YEAR:
9906 case LOCAL:
9907 case WITH:
9908 case ZONE:
9909 case CHARACTER:
9910 case AFTER:
9911 case BEFORE:
9912 case OLD:
9913 case PARENT:
9914 case CC_IF:
9915 case CC_ERROR:
9916 case ANALYZE:
9917 case ASSOCIATE:
9918 case AUDIT:
9919 case COMPOUND:
9920 case DATABASE:
9921 case CALL:
9922 case DDL:
9923 case DISASSOCIATE:
9924 case EACH:
9925 case FOLLOWS:
9926 case LOGOFF:
9927 case LOGON:
9928 case NESTED:
9929 case NOAUDIT:
9930 case SCHEMA:
9931 case SERVERERROR:
9932 case SHUTDOWN:
9933 case STARTUP:
9934 case STATEMENT:
9935 case STATISTICS:
9936 case SUSPEND:
9937 case TRUNCATE:
9938 case WRAPPED:
9939 case LIBRARY:
9940 case NAME:
9941 case STRUCT:
9942 case CONTEXT:
9943 case PARAMETERS:
9944 case LENGTH:
9945 case TDO:
9946 case MAXLEN:
9947 case CHARSETID:
9948 case CHARSETFORM:
9949 case ACCEPT:
9950 case ACCESSIBLE:
9951 case COPY:
9952 case DEFINE:
9953 case DISCONNECT:
9954 case HOST:
9955 case PRINT:
9956 case QUIT:
9957 case REMARK:
9958 case UNDEFINE:
9959 case VARIABLE:
9960 case WHENEVER:
9961 case ATTACH:
9962 case CAST:
9963 case TREAT:
9964 case TRIM:
9965 case LEFT:
9966 case RIGHT:
9967 case BOTH:
9968 case EMPTY:
9969 case MULTISET:
9970 case SUBMULTISET:
9971 case LEADING:
9972 case TRAILING:
9973 case CHAR_CS:
9974 case NCHAR_CS:
9975 case DBTIMEZONE:
9976 case SESSIONTIMEZONE:
9977 case AUTHENTICATED:
9978 case LINK:
9979 case SHARED:
9980 case DIRECTORY:
9981 case USER:
9982 case IDENTIFIER:
9983 case UNSIGNED_NUMERIC_LITERAL:
9984 case CHARACTER_LITERAL:
9985 case STRING_LITERAL:
9986 case QUOTED_LITERAL:
9987 UnlabelledStatement();
9988 break;
9989 default:
9990 jj_la1[122] = jj_gen;
9991 jj_consume_token(-1);
9992 throw new ParseException();
9993 }
9994 jjtree.closeNodeScope(jjtn000, true);
9995 jjtc000 = false;
9996 {if (true) return jjtn000 ;}
9997 } catch (Throwable jjte000) {
9998 if (jjtc000) {
9999 jjtree.clearNodeScope(jjtn000);
10000 jjtc000 = false;
10001 } else {
10002 jjtree.popNode();
10003 }
10004 if (jjte000 instanceof RuntimeException) {
10005 {if (true) throw (RuntimeException)jjte000;}
10006 }
10007 if (jjte000 instanceof ParseException) {
10008 {if (true) throw (ParseException)jjte000;}
10009 }
10010 {if (true) throw (Error)jjte000;}
10011 } finally {
10012 if (jjtc000) {
10013 jjtree.closeNodeScope(jjtn000, true);
10014 }
10015 }
10016 throw new Error("Missing return statement in function");
10017 }
10018
10019
10020
10021
10022
10023 final public ASTLabelledStatement LabelledStatement() throws ParseException {
10024
10025 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10026 boolean jjtc000 = true;
10027 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10028 try {
10029 label_24:
10030 while (true) {
10031 simpleNode = Label();
10032 switch (jj_nt.kind) {
10033 case 21:
10034 ;
10035 break;
10036 default:
10037 jj_la1[123] = jj_gen;
10038 break label_24;
10039 }
10040 }
10041 UnlabelledStatement();
10042 jjtree.closeNodeScope(jjtn000, true);
10043 jjtc000 = false;
10044 jjtn000.setImage( simpleNode.getImage() ) ;
10045 {if (true) return jjtn000 ;}
10046 } catch (Throwable jjte000) {
10047 if (jjtc000) {
10048 jjtree.clearNodeScope(jjtn000);
10049 jjtc000 = false;
10050 } else {
10051 jjtree.popNode();
10052 }
10053 if (jjte000 instanceof RuntimeException) {
10054 {if (true) throw (RuntimeException)jjte000;}
10055 }
10056 if (jjte000 instanceof ParseException) {
10057 {if (true) throw (ParseException)jjte000;}
10058 }
10059 {if (true) throw (Error)jjte000;}
10060 } finally {
10061 if (jjtc000) {
10062 jjtree.closeNodeScope(jjtn000, true);
10063 }
10064 }
10065 throw new Error("Missing return statement in function");
10066 }
10067
10068 final public ASTCaseStatement CaseStatement() throws ParseException {
10069
10070 ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10071 boolean jjtc000 = true;
10072 jjtree.openNodeScope(jjtn000);
10073 try {
10074 jj_consume_token(CASE);
10075 switch (jj_nt.kind) {
10076 case 5:
10077 case 16:
10078 case 17:
10079 case REPLACE:
10080 case DEFINER:
10081 case CURRENT_USER:
10082 case LANGUAGE:
10083 case INLINE:
10084 case ADD:
10085 case AGGREGATE:
10086 case ARRAY:
10087 case AT:
10088 case ATTRIBUTE:
10089 case AUTHID:
10090 case BODY:
10091 case BULK:
10092 case BYTE:
10093 case CASCADE:
10094 case CASE:
10095 case CLOSE:
10096 case COALESCE:
10097 case COLLECT:
10098 case COLUMN:
10099 case COMMENT:
10100 case COMMIT:
10101 case CONSTRUCTOR:
10102 case CONTINUE:
10103 case CONVERT:
10104 case CURRENT:
10105 case CURSOR:
10106 case DATA:
10107 case DATE:
10108 case DAY:
10109 case DISABLE:
10110 case EDITIONABLE:
10111 case ELEMENT:
10112 case ENABLE:
10113 case ESCAPE:
10114 case EXCEPT:
10115 case EXCEPTIONS:
10116 case EXIT:
10117 case EXTERNAL:
10118 case EXTENDS:
10119 case EXTRACT:
10120 case FALSE:
10121 case FINAL:
10122 case FORCE:
10123 case FUNCTION:
10124 case GLOBAL:
10125 case HASH:
10126 case HEAP:
10127 case HOUR:
10128 case IMMEDIATE:
10129 case INDICES:
10130 case INDEXTYPE:
10131 case INDICATOR:
10132 case INSTANTIABLE:
10133 case INTERVAL:
10134 case INVALIDATE:
10135 case ISOLATION:
10136 case JAVA:
10137 case LEVEL:
10138 case LIMIT:
10139 case LOOP:
10140 case MAP:
10141 case MAX:
10142 case MEMBER:
10143 case MERGE:
10144 case MIN:
10145 case MINUTE:
10146 case MLSLABEL:
10147 case MODIFY:
10148 case MOD:
10149 case MONTH:
10150 case NATURAL:
10151 case NEW:
10152 case NEW_DOT:
10153 case NO:
10154 case NONEDITIONABLE:
10155 case NOT:
10156 case NULL:
10157 case NULLIF:
10158 case OBJECT:
10159 case OID:
10160 case OPAQUE:
10161 case OPEN:
10162 case OPERATOR:
10163 case ORGANIZATION:
10164 case OTHERS:
10165 case OVERRIDING:
10166 case PACKAGE:
10167 case PARTITION:
10168 case PRESERVE:
10169 case PRIVATE:
10170 case PROCEDURE:
10171 case RANGE:
10172 case RAW:
10173 case REAL:
10174 case RECORD:
10175 case REF:
10176 case RELEASE:
10177 case RELIES_ON:
10178 case RENAME:
10179 case RESULT:
10180 case RETURN:
10181 case RETURNING:
10182 case REVERSE:
10183 case ROLLBACK:
10184 case ROW:
10185 case ROWS:
10186 case ROWID:
10187 case ROWNUM:
10188 case SAVE:
10189 case SAVEPOINT:
10190 case SECOND:
10191 case SELECT:
10192 case SELF:
10193 case SET:
10194 case SPACE:
10195 case SQL:
10196 case SQLCODE:
10197 case SQLERRM:
10198 case STATIC:
10199 case SUBTYPE:
10200 case SUBSTITUTABLE:
10201 case SUCCESSFUL:
10202 case SYSDATE:
10203 case SYS_REFCURSOR:
10204 case TEMPORARY:
10205 case TIME:
10206 case TIMESTAMP:
10207 case TIMEZONE_REGION:
10208 case TIMEZONE_ABBR:
10209 case TIMEZONE_MINUTE:
10210 case TIMEZONE_HOUR:
10211 case TRANSACTION:
10212 case TRUE:
10213 case TYPE:
10214 case UNDER:
10215 case USING:
10216 case YES:
10217 case SHOW:
10218 case A:
10219 case DOUBLE:
10220 case DEC:
10221 case PRECISION:
10222 case INT:
10223 case NUMERIC:
10224 case NCHAR:
10225 case NVARCHAR2:
10226 case STRING:
10227 case UROWID:
10228 case VARRAY:
10229 case VARYING:
10230 case BFILE:
10231 case BLOB:
10232 case CLOB:
10233 case NCLOB:
10234 case YEAR:
10235 case LOCAL:
10236 case WITH:
10237 case ZONE:
10238 case CHARACTER:
10239 case AFTER:
10240 case BEFORE:
10241 case OLD:
10242 case PARENT:
10243 case CC_IF:
10244 case ANALYZE:
10245 case ASSOCIATE:
10246 case AUDIT:
10247 case COMPOUND:
10248 case DATABASE:
10249 case CALL:
10250 case DDL:
10251 case DISASSOCIATE:
10252 case EACH:
10253 case FOLLOWS:
10254 case LOGOFF:
10255 case LOGON:
10256 case NESTED:
10257 case NOAUDIT:
10258 case SCHEMA:
10259 case SERVERERROR:
10260 case SHUTDOWN:
10261 case STARTUP:
10262 case STATEMENT:
10263 case STATISTICS:
10264 case SUSPEND:
10265 case TRUNCATE:
10266 case WRAPPED:
10267 case LIBRARY:
10268 case NAME:
10269 case STRUCT:
10270 case CONTEXT:
10271 case PARAMETERS:
10272 case LENGTH:
10273 case TDO:
10274 case MAXLEN:
10275 case CHARSETID:
10276 case CHARSETFORM:
10277 case ACCEPT:
10278 case ACCESSIBLE:
10279 case COPY:
10280 case DEFINE:
10281 case DISCONNECT:
10282 case HOST:
10283 case PRINT:
10284 case QUIT:
10285 case REMARK:
10286 case UNDEFINE:
10287 case VARIABLE:
10288 case WHENEVER:
10289 case ATTACH:
10290 case CAST:
10291 case TREAT:
10292 case TRIM:
10293 case LEFT:
10294 case RIGHT:
10295 case BOTH:
10296 case EMPTY:
10297 case MULTISET:
10298 case SUBMULTISET:
10299 case LEADING:
10300 case TRAILING:
10301 case CHAR_CS:
10302 case NCHAR_CS:
10303 case DBTIMEZONE:
10304 case SESSIONTIMEZONE:
10305 case AUTHENTICATED:
10306 case LINK:
10307 case SHARED:
10308 case DIRECTORY:
10309 case USER:
10310 case IDENTIFIER:
10311 case UNSIGNED_NUMERIC_LITERAL:
10312 case CHARACTER_LITERAL:
10313 case STRING_LITERAL:
10314 case QUOTED_LITERAL:
10315 Expression();
10316 break;
10317 default:
10318 jj_la1[124] = jj_gen;
10319 ;
10320 }
10321 label_25:
10322 while (true) {
10323 switch (jj_nt.kind) {
10324 case WHEN:
10325 ;
10326 break;
10327 default:
10328 jj_la1[125] = jj_gen;
10329 break label_25;
10330 }
10331 CaseWhenClause();
10332 }
10333 switch (jj_nt.kind) {
10334 case ELSE:
10335 ElseClause();
10336 break;
10337 default:
10338 jj_la1[126] = jj_gen;
10339 ;
10340 }
10341 jj_consume_token(END);
10342 jj_consume_token(CASE);
10343 switch (jj_nt.kind) {
10344 case IDENTIFIER:
10345 jj_consume_token(IDENTIFIER);
10346 break;
10347 default:
10348 jj_la1[127] = jj_gen;
10349 ;
10350 }
10351 jjtree.closeNodeScope(jjtn000, true);
10352 jjtc000 = false;
10353 {if (true) return jjtn000 ;}
10354 } catch (Throwable jjte000) {
10355 if (jjtc000) {
10356 jjtree.clearNodeScope(jjtn000);
10357 jjtc000 = false;
10358 } else {
10359 jjtree.popNode();
10360 }
10361 if (jjte000 instanceof RuntimeException) {
10362 {if (true) throw (RuntimeException)jjte000;}
10363 }
10364 if (jjte000 instanceof ParseException) {
10365 {if (true) throw (ParseException)jjte000;}
10366 }
10367 {if (true) throw (Error)jjte000;}
10368 } finally {
10369 if (jjtc000) {
10370 jjtree.closeNodeScope(jjtn000, true);
10371 }
10372 }
10373 throw new Error("Missing return statement in function");
10374 }
10375
10376 final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10377
10378 ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10379 boolean jjtc000 = true;
10380 jjtree.openNodeScope(jjtn000);
10381 try {
10382 jj_consume_token(WHEN);
10383 Expression();
10384 jj_consume_token(THEN);
10385 label_26:
10386 while (true) {
10387 Statement();
10388 switch (jj_nt.kind) {
10389 case 5:
10390 case 16:
10391 case 17:
10392 case 21:
10393 case REPLACE:
10394 case DEFINER:
10395 case CURRENT_USER:
10396 case LANGUAGE:
10397 case INLINE:
10398 case ADD:
10399 case AGGREGATE:
10400 case ARRAY:
10401 case AT:
10402 case ATTRIBUTE:
10403 case AUTHID:
10404 case BEGIN:
10405 case BODY:
10406 case BULK:
10407 case BYTE:
10408 case CASCADE:
10409 case CASE:
10410 case CLOSE:
10411 case COALESCE:
10412 case COLLECT:
10413 case COLUMN:
10414 case COMMENT:
10415 case COMMIT:
10416 case CONSTRUCTOR:
10417 case CONTINUE:
10418 case CONVERT:
10419 case CURRENT:
10420 case CURSOR:
10421 case DATA:
10422 case DATE:
10423 case DAY:
10424 case DECLARE:
10425 case DELETE:
10426 case DISABLE:
10427 case EDITIONABLE:
10428 case ELEMENT:
10429 case ENABLE:
10430 case ESCAPE:
10431 case EXCEPT:
10432 case EXCEPTIONS:
10433 case EXECUTE:
10434 case EXIT:
10435 case EXTERNAL:
10436 case EXTENDS:
10437 case EXTRACT:
10438 case FALSE:
10439 case FETCH:
10440 case FINAL:
10441 case FOR:
10442 case FORALL:
10443 case FORCE:
10444 case FUNCTION:
10445 case GLOBAL:
10446 case GOTO:
10447 case HASH:
10448 case HEAP:
10449 case HOUR:
10450 case IF:
10451 case IMMEDIATE:
10452 case INDICES:
10453 case INDEXTYPE:
10454 case INDICATOR:
10455 case INSERT:
10456 case INSTANTIABLE:
10457 case INTERVAL:
10458 case INVALIDATE:
10459 case ISOLATION:
10460 case JAVA:
10461 case LEVEL:
10462 case LIMIT:
10463 case LOCK:
10464 case LOOP:
10465 case MAP:
10466 case MAX:
10467 case MEMBER:
10468 case MERGE:
10469 case MIN:
10470 case MINUTE:
10471 case MLSLABEL:
10472 case MODIFY:
10473 case MOD:
10474 case MONTH:
10475 case NATURAL:
10476 case NEW:
10477 case NEW_DOT:
10478 case NO:
10479 case NONEDITIONABLE:
10480 case NOT:
10481 case NULL:
10482 case NULLIF:
10483 case OBJECT:
10484 case OID:
10485 case OPAQUE:
10486 case OPEN:
10487 case OPERATOR:
10488 case ORGANIZATION:
10489 case OTHERS:
10490 case OVERRIDING:
10491 case PACKAGE:
10492 case PARTITION:
10493 case PIPE:
10494 case PRAGMA:
10495 case PRESERVE:
10496 case PRIVATE:
10497 case PROCEDURE:
10498 case RAISE:
10499 case RANGE:
10500 case RAW:
10501 case REAL:
10502 case RECORD:
10503 case REF:
10504 case RELEASE:
10505 case RELIES_ON:
10506 case RENAME:
10507 case RESULT:
10508 case RETURN:
10509 case RETURNING:
10510 case REVERSE:
10511 case ROLLBACK:
10512 case ROW:
10513 case ROWS:
10514 case ROWID:
10515 case ROWNUM:
10516 case SAVE:
10517 case SAVEPOINT:
10518 case SECOND:
10519 case SELECT:
10520 case SELF:
10521 case SET:
10522 case SPACE:
10523 case SQL:
10524 case SQLCODE:
10525 case SQLERRM:
10526 case STATIC:
10527 case SUBTYPE:
10528 case SUBSTITUTABLE:
10529 case SUCCESSFUL:
10530 case SYSDATE:
10531 case SYS_REFCURSOR:
10532 case TEMPORARY:
10533 case TIME:
10534 case TIMESTAMP:
10535 case TIMEZONE_REGION:
10536 case TIMEZONE_ABBR:
10537 case TIMEZONE_MINUTE:
10538 case TIMEZONE_HOUR:
10539 case TRANSACTION:
10540 case TRUE:
10541 case TYPE:
10542 case UNDER:
10543 case USING:
10544 case WHILE:
10545 case YES:
10546 case SHOW:
10547 case A:
10548 case UPDATE:
10549 case DOUBLE:
10550 case DEC:
10551 case PRECISION:
10552 case INT:
10553 case NUMERIC:
10554 case NCHAR:
10555 case NVARCHAR2:
10556 case STRING:
10557 case UROWID:
10558 case VARRAY:
10559 case VARYING:
10560 case BFILE:
10561 case BLOB:
10562 case CLOB:
10563 case NCLOB:
10564 case YEAR:
10565 case LOCAL:
10566 case WITH:
10567 case ZONE:
10568 case CHARACTER:
10569 case AFTER:
10570 case BEFORE:
10571 case OLD:
10572 case PARENT:
10573 case CC_IF:
10574 case CC_ERROR:
10575 case ANALYZE:
10576 case ASSOCIATE:
10577 case AUDIT:
10578 case COMPOUND:
10579 case DATABASE:
10580 case CALL:
10581 case DDL:
10582 case DISASSOCIATE:
10583 case EACH:
10584 case FOLLOWS:
10585 case LOGOFF:
10586 case LOGON:
10587 case NESTED:
10588 case NOAUDIT:
10589 case SCHEMA:
10590 case SERVERERROR:
10591 case SHUTDOWN:
10592 case STARTUP:
10593 case STATEMENT:
10594 case STATISTICS:
10595 case SUSPEND:
10596 case TRUNCATE:
10597 case WRAPPED:
10598 case LIBRARY:
10599 case NAME:
10600 case STRUCT:
10601 case CONTEXT:
10602 case PARAMETERS:
10603 case LENGTH:
10604 case TDO:
10605 case MAXLEN:
10606 case CHARSETID:
10607 case CHARSETFORM:
10608 case ACCEPT:
10609 case ACCESSIBLE:
10610 case COPY:
10611 case DEFINE:
10612 case DISCONNECT:
10613 case HOST:
10614 case PRINT:
10615 case QUIT:
10616 case REMARK:
10617 case UNDEFINE:
10618 case VARIABLE:
10619 case WHENEVER:
10620 case ATTACH:
10621 case CAST:
10622 case TREAT:
10623 case TRIM:
10624 case LEFT:
10625 case RIGHT:
10626 case BOTH:
10627 case EMPTY:
10628 case MULTISET:
10629 case SUBMULTISET:
10630 case LEADING:
10631 case TRAILING:
10632 case CHAR_CS:
10633 case NCHAR_CS:
10634 case DBTIMEZONE:
10635 case SESSIONTIMEZONE:
10636 case AUTHENTICATED:
10637 case LINK:
10638 case SHARED:
10639 case DIRECTORY:
10640 case USER:
10641 case IDENTIFIER:
10642 case UNSIGNED_NUMERIC_LITERAL:
10643 case CHARACTER_LITERAL:
10644 case STRING_LITERAL:
10645 case QUOTED_LITERAL:
10646 ;
10647 break;
10648 default:
10649 jj_la1[128] = jj_gen;
10650 break label_26;
10651 }
10652 }
10653 jjtree.closeNodeScope(jjtn000, true);
10654 jjtc000 = false;
10655 {if (true) return jjtn000 ;}
10656 } catch (Throwable jjte000) {
10657 if (jjtc000) {
10658 jjtree.clearNodeScope(jjtn000);
10659 jjtc000 = false;
10660 } else {
10661 jjtree.popNode();
10662 }
10663 if (jjte000 instanceof RuntimeException) {
10664 {if (true) throw (RuntimeException)jjte000;}
10665 }
10666 if (jjte000 instanceof ParseException) {
10667 {if (true) throw (ParseException)jjte000;}
10668 }
10669 {if (true) throw (Error)jjte000;}
10670 } finally {
10671 if (jjtc000) {
10672 jjtree.closeNodeScope(jjtn000, true);
10673 }
10674 }
10675 throw new Error("Missing return statement in function");
10676 }
10677
10678 final public ASTElseClause ElseClause() throws ParseException {
10679
10680 ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10681 boolean jjtc000 = true;
10682 jjtree.openNodeScope(jjtn000);
10683 try {
10684 jj_consume_token(ELSE);
10685 label_27:
10686 while (true) {
10687 Statement();
10688 switch (jj_nt.kind) {
10689 case 5:
10690 case 16:
10691 case 17:
10692 case 21:
10693 case REPLACE:
10694 case DEFINER:
10695 case CURRENT_USER:
10696 case LANGUAGE:
10697 case INLINE:
10698 case ADD:
10699 case AGGREGATE:
10700 case ARRAY:
10701 case AT:
10702 case ATTRIBUTE:
10703 case AUTHID:
10704 case BEGIN:
10705 case BODY:
10706 case BULK:
10707 case BYTE:
10708 case CASCADE:
10709 case CASE:
10710 case CLOSE:
10711 case COALESCE:
10712 case COLLECT:
10713 case COLUMN:
10714 case COMMENT:
10715 case COMMIT:
10716 case CONSTRUCTOR:
10717 case CONTINUE:
10718 case CONVERT:
10719 case CURRENT:
10720 case CURSOR:
10721 case DATA:
10722 case DATE:
10723 case DAY:
10724 case DECLARE:
10725 case DELETE:
10726 case DISABLE:
10727 case EDITIONABLE:
10728 case ELEMENT:
10729 case ENABLE:
10730 case ESCAPE:
10731 case EXCEPT:
10732 case EXCEPTIONS:
10733 case EXECUTE:
10734 case EXIT:
10735 case EXTERNAL:
10736 case EXTENDS:
10737 case EXTRACT:
10738 case FALSE:
10739 case FETCH:
10740 case FINAL:
10741 case FOR:
10742 case FORALL:
10743 case FORCE:
10744 case FUNCTION:
10745 case GLOBAL:
10746 case GOTO:
10747 case HASH:
10748 case HEAP:
10749 case HOUR:
10750 case IF:
10751 case IMMEDIATE:
10752 case INDICES:
10753 case INDEXTYPE:
10754 case INDICATOR:
10755 case INSERT:
10756 case INSTANTIABLE:
10757 case INTERVAL:
10758 case INVALIDATE:
10759 case ISOLATION:
10760 case JAVA:
10761 case LEVEL:
10762 case LIMIT:
10763 case LOCK:
10764 case LOOP:
10765 case MAP:
10766 case MAX:
10767 case MEMBER:
10768 case MERGE:
10769 case MIN:
10770 case MINUTE:
10771 case MLSLABEL:
10772 case MODIFY:
10773 case MOD:
10774 case MONTH:
10775 case NATURAL:
10776 case NEW:
10777 case NEW_DOT:
10778 case NO:
10779 case NONEDITIONABLE:
10780 case NOT:
10781 case NULL:
10782 case NULLIF:
10783 case OBJECT:
10784 case OID:
10785 case OPAQUE:
10786 case OPEN:
10787 case OPERATOR:
10788 case ORGANIZATION:
10789 case OTHERS:
10790 case OVERRIDING:
10791 case PACKAGE:
10792 case PARTITION:
10793 case PIPE:
10794 case PRAGMA:
10795 case PRESERVE:
10796 case PRIVATE:
10797 case PROCEDURE:
10798 case RAISE:
10799 case RANGE:
10800 case RAW:
10801 case REAL:
10802 case RECORD:
10803 case REF:
10804 case RELEASE:
10805 case RELIES_ON:
10806 case RENAME:
10807 case RESULT:
10808 case RETURN:
10809 case RETURNING:
10810 case REVERSE:
10811 case ROLLBACK:
10812 case ROW:
10813 case ROWS:
10814 case ROWID:
10815 case ROWNUM:
10816 case SAVE:
10817 case SAVEPOINT:
10818 case SECOND:
10819 case SELECT:
10820 case SELF:
10821 case SET:
10822 case SPACE:
10823 case SQL:
10824 case SQLCODE:
10825 case SQLERRM:
10826 case STATIC:
10827 case SUBTYPE:
10828 case SUBSTITUTABLE:
10829 case SUCCESSFUL:
10830 case SYSDATE:
10831 case SYS_REFCURSOR:
10832 case TEMPORARY:
10833 case TIME:
10834 case TIMESTAMP:
10835 case TIMEZONE_REGION:
10836 case TIMEZONE_ABBR:
10837 case TIMEZONE_MINUTE:
10838 case TIMEZONE_HOUR:
10839 case TRANSACTION:
10840 case TRUE:
10841 case TYPE:
10842 case UNDER:
10843 case USING:
10844 case WHILE:
10845 case YES:
10846 case SHOW:
10847 case A:
10848 case UPDATE:
10849 case DOUBLE:
10850 case DEC:
10851 case PRECISION:
10852 case INT:
10853 case NUMERIC:
10854 case NCHAR:
10855 case NVARCHAR2:
10856 case STRING:
10857 case UROWID:
10858 case VARRAY:
10859 case VARYING:
10860 case BFILE:
10861 case BLOB:
10862 case CLOB:
10863 case NCLOB:
10864 case YEAR:
10865 case LOCAL:
10866 case WITH:
10867 case ZONE:
10868 case CHARACTER:
10869 case AFTER:
10870 case BEFORE:
10871 case OLD:
10872 case PARENT:
10873 case CC_IF:
10874 case CC_ERROR:
10875 case ANALYZE:
10876 case ASSOCIATE:
10877 case AUDIT:
10878 case COMPOUND:
10879 case DATABASE:
10880 case CALL:
10881 case DDL:
10882 case DISASSOCIATE:
10883 case EACH:
10884 case FOLLOWS:
10885 case LOGOFF:
10886 case LOGON:
10887 case NESTED:
10888 case NOAUDIT:
10889 case SCHEMA:
10890 case SERVERERROR:
10891 case SHUTDOWN:
10892 case STARTUP:
10893 case STATEMENT:
10894 case STATISTICS:
10895 case SUSPEND:
10896 case TRUNCATE:
10897 case WRAPPED:
10898 case LIBRARY:
10899 case NAME:
10900 case STRUCT:
10901 case CONTEXT:
10902 case PARAMETERS:
10903 case LENGTH:
10904 case TDO:
10905 case MAXLEN:
10906 case CHARSETID:
10907 case CHARSETFORM:
10908 case ACCEPT:
10909 case ACCESSIBLE:
10910 case COPY:
10911 case DEFINE:
10912 case DISCONNECT:
10913 case HOST:
10914 case PRINT:
10915 case QUIT:
10916 case REMARK:
10917 case UNDEFINE:
10918 case VARIABLE:
10919 case WHENEVER:
10920 case ATTACH:
10921 case CAST:
10922 case TREAT:
10923 case TRIM:
10924 case LEFT:
10925 case RIGHT:
10926 case BOTH:
10927 case EMPTY:
10928 case MULTISET:
10929 case SUBMULTISET:
10930 case LEADING:
10931 case TRAILING:
10932 case CHAR_CS:
10933 case NCHAR_CS:
10934 case DBTIMEZONE:
10935 case SESSIONTIMEZONE:
10936 case AUTHENTICATED:
10937 case LINK:
10938 case SHARED:
10939 case DIRECTORY:
10940 case USER:
10941 case IDENTIFIER:
10942 case UNSIGNED_NUMERIC_LITERAL:
10943 case CHARACTER_LITERAL:
10944 case STRING_LITERAL:
10945 case QUOTED_LITERAL:
10946 ;
10947 break;
10948 default:
10949 jj_la1[129] = jj_gen;
10950 break label_27;
10951 }
10952 }
10953 jjtree.closeNodeScope(jjtn000, true);
10954 jjtc000 = false;
10955 {if (true) return jjtn000 ;}
10956 } catch (Throwable jjte000) {
10957 if (jjtc000) {
10958 jjtree.clearNodeScope(jjtn000);
10959 jjtc000 = false;
10960 } else {
10961 jjtree.popNode();
10962 }
10963 if (jjte000 instanceof RuntimeException) {
10964 {if (true) throw (RuntimeException)jjte000;}
10965 }
10966 if (jjte000 instanceof ParseException) {
10967 {if (true) throw (ParseException)jjte000;}
10968 }
10969 {if (true) throw (Error)jjte000;}
10970 } finally {
10971 if (jjtc000) {
10972 jjtree.closeNodeScope(jjtn000, true);
10973 }
10974 }
10975 throw new Error("Missing return statement in function");
10976 }
10977
10978 final public ASTElsifClause ElsifClause() throws ParseException {
10979
10980 ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10981 boolean jjtc000 = true;
10982 jjtree.openNodeScope(jjtn000);
10983 try {
10984 jj_consume_token(ELSIF);
10985 Expression();
10986 jj_consume_token(THEN);
10987 label_28:
10988 while (true) {
10989 Statement();
10990 switch (jj_nt.kind) {
10991 case 5:
10992 case 16:
10993 case 17:
10994 case 21:
10995 case REPLACE:
10996 case DEFINER:
10997 case CURRENT_USER:
10998 case LANGUAGE:
10999 case INLINE:
11000 case ADD:
11001 case AGGREGATE:
11002 case ARRAY:
11003 case AT:
11004 case ATTRIBUTE:
11005 case AUTHID:
11006 case BEGIN:
11007 case BODY:
11008 case BULK:
11009 case BYTE:
11010 case CASCADE:
11011 case CASE:
11012 case CLOSE:
11013 case COALESCE:
11014 case COLLECT:
11015 case COLUMN:
11016 case COMMENT:
11017 case COMMIT:
11018 case CONSTRUCTOR:
11019 case CONTINUE:
11020 case CONVERT:
11021 case CURRENT:
11022 case CURSOR:
11023 case DATA:
11024 case DATE:
11025 case DAY:
11026 case DECLARE:
11027 case DELETE:
11028 case DISABLE:
11029 case EDITIONABLE:
11030 case ELEMENT:
11031 case ENABLE:
11032 case ESCAPE:
11033 case EXCEPT:
11034 case EXCEPTIONS:
11035 case EXECUTE:
11036 case EXIT:
11037 case EXTERNAL:
11038 case EXTENDS:
11039 case EXTRACT:
11040 case FALSE:
11041 case FETCH:
11042 case FINAL:
11043 case FOR:
11044 case FORALL:
11045 case FORCE:
11046 case FUNCTION:
11047 case GLOBAL:
11048 case GOTO:
11049 case HASH:
11050 case HEAP:
11051 case HOUR:
11052 case IF:
11053 case IMMEDIATE:
11054 case INDICES:
11055 case INDEXTYPE:
11056 case INDICATOR:
11057 case INSERT:
11058 case INSTANTIABLE:
11059 case INTERVAL:
11060 case INVALIDATE:
11061 case ISOLATION:
11062 case JAVA:
11063 case LEVEL:
11064 case LIMIT:
11065 case LOCK:
11066 case LOOP:
11067 case MAP:
11068 case MAX:
11069 case MEMBER:
11070 case MERGE:
11071 case MIN:
11072 case MINUTE:
11073 case MLSLABEL:
11074 case MODIFY:
11075 case MOD:
11076 case MONTH:
11077 case NATURAL:
11078 case NEW:
11079 case NEW_DOT:
11080 case NO:
11081 case NONEDITIONABLE:
11082 case NOT:
11083 case NULL:
11084 case NULLIF:
11085 case OBJECT:
11086 case OID:
11087 case OPAQUE:
11088 case OPEN:
11089 case OPERATOR:
11090 case ORGANIZATION:
11091 case OTHERS:
11092 case OVERRIDING:
11093 case PACKAGE:
11094 case PARTITION:
11095 case PIPE:
11096 case PRAGMA:
11097 case PRESERVE:
11098 case PRIVATE:
11099 case PROCEDURE:
11100 case RAISE:
11101 case RANGE:
11102 case RAW:
11103 case REAL:
11104 case RECORD:
11105 case REF:
11106 case RELEASE:
11107 case RELIES_ON:
11108 case RENAME:
11109 case RESULT:
11110 case RETURN:
11111 case RETURNING:
11112 case REVERSE:
11113 case ROLLBACK:
11114 case ROW:
11115 case ROWS:
11116 case ROWID:
11117 case ROWNUM:
11118 case SAVE:
11119 case SAVEPOINT:
11120 case SECOND:
11121 case SELECT:
11122 case SELF:
11123 case SET:
11124 case SPACE:
11125 case SQL:
11126 case SQLCODE:
11127 case SQLERRM:
11128 case STATIC:
11129 case SUBTYPE:
11130 case SUBSTITUTABLE:
11131 case SUCCESSFUL:
11132 case SYSDATE:
11133 case SYS_REFCURSOR:
11134 case TEMPORARY:
11135 case TIME:
11136 case TIMESTAMP:
11137 case TIMEZONE_REGION:
11138 case TIMEZONE_ABBR:
11139 case TIMEZONE_MINUTE:
11140 case TIMEZONE_HOUR:
11141 case TRANSACTION:
11142 case TRUE:
11143 case TYPE:
11144 case UNDER:
11145 case USING:
11146 case WHILE:
11147 case YES:
11148 case SHOW:
11149 case A:
11150 case UPDATE:
11151 case DOUBLE:
11152 case DEC:
11153 case PRECISION:
11154 case INT:
11155 case NUMERIC:
11156 case NCHAR:
11157 case NVARCHAR2:
11158 case STRING:
11159 case UROWID:
11160 case VARRAY:
11161 case VARYING:
11162 case BFILE:
11163 case BLOB:
11164 case CLOB:
11165 case NCLOB:
11166 case YEAR:
11167 case LOCAL:
11168 case WITH:
11169 case ZONE:
11170 case CHARACTER:
11171 case AFTER:
11172 case BEFORE:
11173 case OLD:
11174 case PARENT:
11175 case CC_IF:
11176 case CC_ERROR:
11177 case ANALYZE:
11178 case ASSOCIATE:
11179 case AUDIT:
11180 case COMPOUND:
11181 case DATABASE:
11182 case CALL:
11183 case DDL:
11184 case DISASSOCIATE:
11185 case EACH:
11186 case FOLLOWS:
11187 case LOGOFF:
11188 case LOGON:
11189 case NESTED:
11190 case NOAUDIT:
11191 case SCHEMA:
11192 case SERVERERROR:
11193 case SHUTDOWN:
11194 case STARTUP:
11195 case STATEMENT:
11196 case STATISTICS:
11197 case SUSPEND:
11198 case TRUNCATE:
11199 case WRAPPED:
11200 case LIBRARY:
11201 case NAME:
11202 case STRUCT:
11203 case CONTEXT:
11204 case PARAMETERS:
11205 case LENGTH:
11206 case TDO:
11207 case MAXLEN:
11208 case CHARSETID:
11209 case CHARSETFORM:
11210 case ACCEPT:
11211 case ACCESSIBLE:
11212 case COPY:
11213 case DEFINE:
11214 case DISCONNECT:
11215 case HOST:
11216 case PRINT:
11217 case QUIT:
11218 case REMARK:
11219 case UNDEFINE:
11220 case VARIABLE:
11221 case WHENEVER:
11222 case ATTACH:
11223 case CAST:
11224 case TREAT:
11225 case TRIM:
11226 case LEFT:
11227 case RIGHT:
11228 case BOTH:
11229 case EMPTY:
11230 case MULTISET:
11231 case SUBMULTISET:
11232 case LEADING:
11233 case TRAILING:
11234 case CHAR_CS:
11235 case NCHAR_CS:
11236 case DBTIMEZONE:
11237 case SESSIONTIMEZONE:
11238 case AUTHENTICATED:
11239 case LINK:
11240 case SHARED:
11241 case DIRECTORY:
11242 case USER:
11243 case IDENTIFIER:
11244 case UNSIGNED_NUMERIC_LITERAL:
11245 case CHARACTER_LITERAL:
11246 case STRING_LITERAL:
11247 case QUOTED_LITERAL:
11248 ;
11249 break;
11250 default:
11251 jj_la1[130] = jj_gen;
11252 break label_28;
11253 }
11254 }
11255 jjtree.closeNodeScope(jjtn000, true);
11256 jjtc000 = false;
11257 {if (true) return jjtn000 ;}
11258 } catch (Throwable jjte000) {
11259 if (jjtc000) {
11260 jjtree.clearNodeScope(jjtn000);
11261 jjtc000 = false;
11262 } else {
11263 jjtree.popNode();
11264 }
11265 if (jjte000 instanceof RuntimeException) {
11266 {if (true) throw (RuntimeException)jjte000;}
11267 }
11268 if (jjte000 instanceof ParseException) {
11269 {if (true) throw (ParseException)jjte000;}
11270 }
11271 {if (true) throw (Error)jjte000;}
11272 } finally {
11273 if (jjtc000) {
11274 jjtree.closeNodeScope(jjtn000, true);
11275 }
11276 }
11277 throw new Error("Missing return statement in function");
11278 }
11279
11280 final public ASTLoopStatement LoopStatement() throws ParseException {
11281
11282 ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11283 boolean jjtc000 = true;
11284 jjtree.openNodeScope(jjtn000);
11285 try {
11286 jj_consume_token(LOOP);
11287 label_29:
11288 while (true) {
11289 Statement();
11290 switch (jj_nt.kind) {
11291 case 5:
11292 case 16:
11293 case 17:
11294 case 21:
11295 case REPLACE:
11296 case DEFINER:
11297 case CURRENT_USER:
11298 case LANGUAGE:
11299 case INLINE:
11300 case ADD:
11301 case AGGREGATE:
11302 case ARRAY:
11303 case AT:
11304 case ATTRIBUTE:
11305 case AUTHID:
11306 case BEGIN:
11307 case BODY:
11308 case BULK:
11309 case BYTE:
11310 case CASCADE:
11311 case CASE:
11312 case CLOSE:
11313 case COALESCE:
11314 case COLLECT:
11315 case COLUMN:
11316 case COMMENT:
11317 case COMMIT:
11318 case CONSTRUCTOR:
11319 case CONTINUE:
11320 case CONVERT:
11321 case CURRENT:
11322 case CURSOR:
11323 case DATA:
11324 case DATE:
11325 case DAY:
11326 case DECLARE:
11327 case DELETE:
11328 case DISABLE:
11329 case EDITIONABLE:
11330 case ELEMENT:
11331 case ENABLE:
11332 case ESCAPE:
11333 case EXCEPT:
11334 case EXCEPTIONS:
11335 case EXECUTE:
11336 case EXIT:
11337 case EXTERNAL:
11338 case EXTENDS:
11339 case EXTRACT:
11340 case FALSE:
11341 case FETCH:
11342 case FINAL:
11343 case FOR:
11344 case FORALL:
11345 case FORCE:
11346 case FUNCTION:
11347 case GLOBAL:
11348 case GOTO:
11349 case HASH:
11350 case HEAP:
11351 case HOUR:
11352 case IF:
11353 case IMMEDIATE:
11354 case INDICES:
11355 case INDEXTYPE:
11356 case INDICATOR:
11357 case INSERT:
11358 case INSTANTIABLE:
11359 case INTERVAL:
11360 case INVALIDATE:
11361 case ISOLATION:
11362 case JAVA:
11363 case LEVEL:
11364 case LIMIT:
11365 case LOCK:
11366 case LOOP:
11367 case MAP:
11368 case MAX:
11369 case MEMBER:
11370 case MERGE:
11371 case MIN:
11372 case MINUTE:
11373 case MLSLABEL:
11374 case MODIFY:
11375 case MOD:
11376 case MONTH:
11377 case NATURAL:
11378 case NEW:
11379 case NEW_DOT:
11380 case NO:
11381 case NONEDITIONABLE:
11382 case NOT:
11383 case NULL:
11384 case NULLIF:
11385 case OBJECT:
11386 case OID:
11387 case OPAQUE:
11388 case OPEN:
11389 case OPERATOR:
11390 case ORGANIZATION:
11391 case OTHERS:
11392 case OVERRIDING:
11393 case PACKAGE:
11394 case PARTITION:
11395 case PIPE:
11396 case PRAGMA:
11397 case PRESERVE:
11398 case PRIVATE:
11399 case PROCEDURE:
11400 case RAISE:
11401 case RANGE:
11402 case RAW:
11403 case REAL:
11404 case RECORD:
11405 case REF:
11406 case RELEASE:
11407 case RELIES_ON:
11408 case RENAME:
11409 case RESULT:
11410 case RETURN:
11411 case RETURNING:
11412 case REVERSE:
11413 case ROLLBACK:
11414 case ROW:
11415 case ROWS:
11416 case ROWID:
11417 case ROWNUM:
11418 case SAVE:
11419 case SAVEPOINT:
11420 case SECOND:
11421 case SELECT:
11422 case SELF:
11423 case SET:
11424 case SPACE:
11425 case SQL:
11426 case SQLCODE:
11427 case SQLERRM:
11428 case STATIC:
11429 case SUBTYPE:
11430 case SUBSTITUTABLE:
11431 case SUCCESSFUL:
11432 case SYSDATE:
11433 case SYS_REFCURSOR:
11434 case TEMPORARY:
11435 case TIME:
11436 case TIMESTAMP:
11437 case TIMEZONE_REGION:
11438 case TIMEZONE_ABBR:
11439 case TIMEZONE_MINUTE:
11440 case TIMEZONE_HOUR:
11441 case TRANSACTION:
11442 case TRUE:
11443 case TYPE:
11444 case UNDER:
11445 case USING:
11446 case WHILE:
11447 case YES:
11448 case SHOW:
11449 case A:
11450 case UPDATE:
11451 case DOUBLE:
11452 case DEC:
11453 case PRECISION:
11454 case INT:
11455 case NUMERIC:
11456 case NCHAR:
11457 case NVARCHAR2:
11458 case STRING:
11459 case UROWID:
11460 case VARRAY:
11461 case VARYING:
11462 case BFILE:
11463 case BLOB:
11464 case CLOB:
11465 case NCLOB:
11466 case YEAR:
11467 case LOCAL:
11468 case WITH:
11469 case ZONE:
11470 case CHARACTER:
11471 case AFTER:
11472 case BEFORE:
11473 case OLD:
11474 case PARENT:
11475 case CC_IF:
11476 case CC_ERROR:
11477 case ANALYZE:
11478 case ASSOCIATE:
11479 case AUDIT:
11480 case COMPOUND:
11481 case DATABASE:
11482 case CALL:
11483 case DDL:
11484 case DISASSOCIATE:
11485 case EACH:
11486 case FOLLOWS:
11487 case LOGOFF:
11488 case LOGON:
11489 case NESTED:
11490 case NOAUDIT:
11491 case SCHEMA:
11492 case SERVERERROR:
11493 case SHUTDOWN:
11494 case STARTUP:
11495 case STATEMENT:
11496 case STATISTICS:
11497 case SUSPEND:
11498 case TRUNCATE:
11499 case WRAPPED:
11500 case LIBRARY:
11501 case NAME:
11502 case STRUCT:
11503 case CONTEXT:
11504 case PARAMETERS:
11505 case LENGTH:
11506 case TDO:
11507 case MAXLEN:
11508 case CHARSETID:
11509 case CHARSETFORM:
11510 case ACCEPT:
11511 case ACCESSIBLE:
11512 case COPY:
11513 case DEFINE:
11514 case DISCONNECT:
11515 case HOST:
11516 case PRINT:
11517 case QUIT:
11518 case REMARK:
11519 case UNDEFINE:
11520 case VARIABLE:
11521 case WHENEVER:
11522 case ATTACH:
11523 case CAST:
11524 case TREAT:
11525 case TRIM:
11526 case LEFT:
11527 case RIGHT:
11528 case BOTH:
11529 case EMPTY:
11530 case MULTISET:
11531 case SUBMULTISET:
11532 case LEADING:
11533 case TRAILING:
11534 case CHAR_CS:
11535 case NCHAR_CS:
11536 case DBTIMEZONE:
11537 case SESSIONTIMEZONE:
11538 case AUTHENTICATED:
11539 case LINK:
11540 case SHARED:
11541 case DIRECTORY:
11542 case USER:
11543 case IDENTIFIER:
11544 case UNSIGNED_NUMERIC_LITERAL:
11545 case CHARACTER_LITERAL:
11546 case STRING_LITERAL:
11547 case QUOTED_LITERAL:
11548 ;
11549 break;
11550 default:
11551 jj_la1[131] = jj_gen;
11552 break label_29;
11553 }
11554 }
11555 jj_consume_token(END);
11556 jj_consume_token(LOOP);
11557 switch (jj_nt.kind) {
11558 case IDENTIFIER:
11559 jj_consume_token(IDENTIFIER);
11560 break;
11561 default:
11562 jj_la1[132] = jj_gen;
11563 ;
11564 }
11565 jjtree.closeNodeScope(jjtn000, true);
11566 jjtc000 = false;
11567 {if (true) return jjtn000 ;}
11568 } catch (Throwable jjte000) {
11569 if (jjtc000) {
11570 jjtree.clearNodeScope(jjtn000);
11571 jjtc000 = false;
11572 } else {
11573 jjtree.popNode();
11574 }
11575 if (jjte000 instanceof RuntimeException) {
11576 {if (true) throw (RuntimeException)jjte000;}
11577 }
11578 if (jjte000 instanceof ParseException) {
11579 {if (true) throw (ParseException)jjte000;}
11580 }
11581 {if (true) throw (Error)jjte000;}
11582 } finally {
11583 if (jjtc000) {
11584 jjtree.closeNodeScope(jjtn000, true);
11585 }
11586 }
11587 throw new Error("Missing return statement in function");
11588 }
11589
11590
11591 final public ASTForStatement ForStatement() throws ParseException {
11592
11593 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11594 boolean jjtc000 = true;
11595 jjtree.openNodeScope(jjtn000);
11596 try {
11597 jj_consume_token(FOR);
11598 ForIndex();
11599 jj_consume_token(IN);
11600 switch (jj_nt.kind) {
11601 case REVERSE:
11602 jj_consume_token(REVERSE);
11603 break;
11604 default:
11605 jj_la1[133] = jj_gen;
11606 ;
11607 }
11608 Expression();
11609 switch (jj_nt.kind) {
11610 case 12:
11611 jj_consume_token(12);
11612 Expression();
11613 break;
11614 default:
11615 jj_la1[134] = jj_gen;
11616 ;
11617 }
11618 jj_consume_token(LOOP);
11619 label_30:
11620 while (true) {
11621 Statement();
11622 switch (jj_nt.kind) {
11623 case 5:
11624 case 16:
11625 case 17:
11626 case 21:
11627 case REPLACE:
11628 case DEFINER:
11629 case CURRENT_USER:
11630 case LANGUAGE:
11631 case INLINE:
11632 case ADD:
11633 case AGGREGATE:
11634 case ARRAY:
11635 case AT:
11636 case ATTRIBUTE:
11637 case AUTHID:
11638 case BEGIN:
11639 case BODY:
11640 case BULK:
11641 case BYTE:
11642 case CASCADE:
11643 case CASE:
11644 case CLOSE:
11645 case COALESCE:
11646 case COLLECT:
11647 case COLUMN:
11648 case COMMENT:
11649 case COMMIT:
11650 case CONSTRUCTOR:
11651 case CONTINUE:
11652 case CONVERT:
11653 case CURRENT:
11654 case CURSOR:
11655 case DATA:
11656 case DATE:
11657 case DAY:
11658 case DECLARE:
11659 case DELETE:
11660 case DISABLE:
11661 case EDITIONABLE:
11662 case ELEMENT:
11663 case ENABLE:
11664 case ESCAPE:
11665 case EXCEPT:
11666 case EXCEPTIONS:
11667 case EXECUTE:
11668 case EXIT:
11669 case EXTERNAL:
11670 case EXTENDS:
11671 case EXTRACT:
11672 case FALSE:
11673 case FETCH:
11674 case FINAL:
11675 case FOR:
11676 case FORALL:
11677 case FORCE:
11678 case FUNCTION:
11679 case GLOBAL:
11680 case GOTO:
11681 case HASH:
11682 case HEAP:
11683 case HOUR:
11684 case IF:
11685 case IMMEDIATE:
11686 case INDICES:
11687 case INDEXTYPE:
11688 case INDICATOR:
11689 case INSERT:
11690 case INSTANTIABLE:
11691 case INTERVAL:
11692 case INVALIDATE:
11693 case ISOLATION:
11694 case JAVA:
11695 case LEVEL:
11696 case LIMIT:
11697 case LOCK:
11698 case LOOP:
11699 case MAP:
11700 case MAX:
11701 case MEMBER:
11702 case MERGE:
11703 case MIN:
11704 case MINUTE:
11705 case MLSLABEL:
11706 case MODIFY:
11707 case MOD:
11708 case MONTH:
11709 case NATURAL:
11710 case NEW:
11711 case NEW_DOT:
11712 case NO:
11713 case NONEDITIONABLE:
11714 case NOT:
11715 case NULL:
11716 case NULLIF:
11717 case OBJECT:
11718 case OID:
11719 case OPAQUE:
11720 case OPEN:
11721 case OPERATOR:
11722 case ORGANIZATION:
11723 case OTHERS:
11724 case OVERRIDING:
11725 case PACKAGE:
11726 case PARTITION:
11727 case PIPE:
11728 case PRAGMA:
11729 case PRESERVE:
11730 case PRIVATE:
11731 case PROCEDURE:
11732 case RAISE:
11733 case RANGE:
11734 case RAW:
11735 case REAL:
11736 case RECORD:
11737 case REF:
11738 case RELEASE:
11739 case RELIES_ON:
11740 case RENAME:
11741 case RESULT:
11742 case RETURN:
11743 case RETURNING:
11744 case REVERSE:
11745 case ROLLBACK:
11746 case ROW:
11747 case ROWS:
11748 case ROWID:
11749 case ROWNUM:
11750 case SAVE:
11751 case SAVEPOINT:
11752 case SECOND:
11753 case SELECT:
11754 case SELF:
11755 case SET:
11756 case SPACE:
11757 case SQL:
11758 case SQLCODE:
11759 case SQLERRM:
11760 case STATIC:
11761 case SUBTYPE:
11762 case SUBSTITUTABLE:
11763 case SUCCESSFUL:
11764 case SYSDATE:
11765 case SYS_REFCURSOR:
11766 case TEMPORARY:
11767 case TIME:
11768 case TIMESTAMP:
11769 case TIMEZONE_REGION:
11770 case TIMEZONE_ABBR:
11771 case TIMEZONE_MINUTE:
11772 case TIMEZONE_HOUR:
11773 case TRANSACTION:
11774 case TRUE:
11775 case TYPE:
11776 case UNDER:
11777 case USING:
11778 case WHILE:
11779 case YES:
11780 case SHOW:
11781 case A:
11782 case UPDATE:
11783 case DOUBLE:
11784 case DEC:
11785 case PRECISION:
11786 case INT:
11787 case NUMERIC:
11788 case NCHAR:
11789 case NVARCHAR2:
11790 case STRING:
11791 case UROWID:
11792 case VARRAY:
11793 case VARYING:
11794 case BFILE:
11795 case BLOB:
11796 case CLOB:
11797 case NCLOB:
11798 case YEAR:
11799 case LOCAL:
11800 case WITH:
11801 case ZONE:
11802 case CHARACTER:
11803 case AFTER:
11804 case BEFORE:
11805 case OLD:
11806 case PARENT:
11807 case CC_IF:
11808 case CC_ERROR:
11809 case ANALYZE:
11810 case ASSOCIATE:
11811 case AUDIT:
11812 case COMPOUND:
11813 case DATABASE:
11814 case CALL:
11815 case DDL:
11816 case DISASSOCIATE:
11817 case EACH:
11818 case FOLLOWS:
11819 case LOGOFF:
11820 case LOGON:
11821 case NESTED:
11822 case NOAUDIT:
11823 case SCHEMA:
11824 case SERVERERROR:
11825 case SHUTDOWN:
11826 case STARTUP:
11827 case STATEMENT:
11828 case STATISTICS:
11829 case SUSPEND:
11830 case TRUNCATE:
11831 case WRAPPED:
11832 case LIBRARY:
11833 case NAME:
11834 case STRUCT:
11835 case CONTEXT:
11836 case PARAMETERS:
11837 case LENGTH:
11838 case TDO:
11839 case MAXLEN:
11840 case CHARSETID:
11841 case CHARSETFORM:
11842 case ACCEPT:
11843 case ACCESSIBLE:
11844 case COPY:
11845 case DEFINE:
11846 case DISCONNECT:
11847 case HOST:
11848 case PRINT:
11849 case QUIT:
11850 case REMARK:
11851 case UNDEFINE:
11852 case VARIABLE:
11853 case WHENEVER:
11854 case ATTACH:
11855 case CAST:
11856 case TREAT:
11857 case TRIM:
11858 case LEFT:
11859 case RIGHT:
11860 case BOTH:
11861 case EMPTY:
11862 case MULTISET:
11863 case SUBMULTISET:
11864 case LEADING:
11865 case TRAILING:
11866 case CHAR_CS:
11867 case NCHAR_CS:
11868 case DBTIMEZONE:
11869 case SESSIONTIMEZONE:
11870 case AUTHENTICATED:
11871 case LINK:
11872 case SHARED:
11873 case DIRECTORY:
11874 case USER:
11875 case IDENTIFIER:
11876 case UNSIGNED_NUMERIC_LITERAL:
11877 case CHARACTER_LITERAL:
11878 case STRING_LITERAL:
11879 case QUOTED_LITERAL:
11880 ;
11881 break;
11882 default:
11883 jj_la1[135] = jj_gen;
11884 break label_30;
11885 }
11886 }
11887 jj_consume_token(END);
11888 jj_consume_token(LOOP);
11889 switch (jj_nt.kind) {
11890 case IDENTIFIER:
11891 jj_consume_token(IDENTIFIER);
11892 break;
11893 default:
11894 jj_la1[136] = jj_gen;
11895 ;
11896 }
11897 jjtree.closeNodeScope(jjtn000, true);
11898 jjtc000 = false;
11899 {if (true) return jjtn000 ;}
11900 } catch (Throwable jjte000) {
11901 if (jjtc000) {
11902 jjtree.clearNodeScope(jjtn000);
11903 jjtc000 = false;
11904 } else {
11905 jjtree.popNode();
11906 }
11907 if (jjte000 instanceof RuntimeException) {
11908 {if (true) throw (RuntimeException)jjte000;}
11909 }
11910 if (jjte000 instanceof ParseException) {
11911 {if (true) throw (ParseException)jjte000;}
11912 }
11913 {if (true) throw (Error)jjte000;}
11914 } finally {
11915 if (jjtc000) {
11916 jjtree.closeNodeScope(jjtn000, true);
11917 }
11918 }
11919 throw new Error("Missing return statement in function");
11920 }
11921
11922 final public ASTWhileStatement WhileStatement() throws ParseException {
11923
11924 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11925 boolean jjtc000 = true;
11926 jjtree.openNodeScope(jjtn000);
11927 try {
11928 jj_consume_token(WHILE);
11929 Expression();
11930 jj_consume_token(LOOP);
11931 label_31:
11932 while (true) {
11933 Statement();
11934 switch (jj_nt.kind) {
11935 case 5:
11936 case 16:
11937 case 17:
11938 case 21:
11939 case REPLACE:
11940 case DEFINER:
11941 case CURRENT_USER:
11942 case LANGUAGE:
11943 case INLINE:
11944 case ADD:
11945 case AGGREGATE:
11946 case ARRAY:
11947 case AT:
11948 case ATTRIBUTE:
11949 case AUTHID:
11950 case BEGIN:
11951 case BODY:
11952 case BULK:
11953 case BYTE:
11954 case CASCADE:
11955 case CASE:
11956 case CLOSE:
11957 case COALESCE:
11958 case COLLECT:
11959 case COLUMN:
11960 case COMMENT:
11961 case COMMIT:
11962 case CONSTRUCTOR:
11963 case CONTINUE:
11964 case CONVERT:
11965 case CURRENT:
11966 case CURSOR:
11967 case DATA:
11968 case DATE:
11969 case DAY:
11970 case DECLARE:
11971 case DELETE:
11972 case DISABLE:
11973 case EDITIONABLE:
11974 case ELEMENT:
11975 case ENABLE:
11976 case ESCAPE:
11977 case EXCEPT:
11978 case EXCEPTIONS:
11979 case EXECUTE:
11980 case EXIT:
11981 case EXTERNAL:
11982 case EXTENDS:
11983 case EXTRACT:
11984 case FALSE:
11985 case FETCH:
11986 case FINAL:
11987 case FOR:
11988 case FORALL:
11989 case FORCE:
11990 case FUNCTION:
11991 case GLOBAL:
11992 case GOTO:
11993 case HASH:
11994 case HEAP:
11995 case HOUR:
11996 case IF:
11997 case IMMEDIATE:
11998 case INDICES:
11999 case INDEXTYPE:
12000 case INDICATOR:
12001 case INSERT:
12002 case INSTANTIABLE:
12003 case INTERVAL:
12004 case INVALIDATE:
12005 case ISOLATION:
12006 case JAVA:
12007 case LEVEL:
12008 case LIMIT:
12009 case LOCK:
12010 case LOOP:
12011 case MAP:
12012 case MAX:
12013 case MEMBER:
12014 case MERGE:
12015 case MIN:
12016 case MINUTE:
12017 case MLSLABEL:
12018 case MODIFY:
12019 case MOD:
12020 case MONTH:
12021 case NATURAL:
12022 case NEW:
12023 case NEW_DOT:
12024 case NO:
12025 case NONEDITIONABLE:
12026 case NOT:
12027 case NULL:
12028 case NULLIF:
12029 case OBJECT:
12030 case OID:
12031 case OPAQUE:
12032 case OPEN:
12033 case OPERATOR:
12034 case ORGANIZATION:
12035 case OTHERS:
12036 case OVERRIDING:
12037 case PACKAGE:
12038 case PARTITION:
12039 case PIPE:
12040 case PRAGMA:
12041 case PRESERVE:
12042 case PRIVATE:
12043 case PROCEDURE:
12044 case RAISE:
12045 case RANGE:
12046 case RAW:
12047 case REAL:
12048 case RECORD:
12049 case REF:
12050 case RELEASE:
12051 case RELIES_ON:
12052 case RENAME:
12053 case RESULT:
12054 case RETURN:
12055 case RETURNING:
12056 case REVERSE:
12057 case ROLLBACK:
12058 case ROW:
12059 case ROWS:
12060 case ROWID:
12061 case ROWNUM:
12062 case SAVE:
12063 case SAVEPOINT:
12064 case SECOND:
12065 case SELECT:
12066 case SELF:
12067 case SET:
12068 case SPACE:
12069 case SQL:
12070 case SQLCODE:
12071 case SQLERRM:
12072 case STATIC:
12073 case SUBTYPE:
12074 case SUBSTITUTABLE:
12075 case SUCCESSFUL:
12076 case SYSDATE:
12077 case SYS_REFCURSOR:
12078 case TEMPORARY:
12079 case TIME:
12080 case TIMESTAMP:
12081 case TIMEZONE_REGION:
12082 case TIMEZONE_ABBR:
12083 case TIMEZONE_MINUTE:
12084 case TIMEZONE_HOUR:
12085 case TRANSACTION:
12086 case TRUE:
12087 case TYPE:
12088 case UNDER:
12089 case USING:
12090 case WHILE:
12091 case YES:
12092 case SHOW:
12093 case A:
12094 case UPDATE:
12095 case DOUBLE:
12096 case DEC:
12097 case PRECISION:
12098 case INT:
12099 case NUMERIC:
12100 case NCHAR:
12101 case NVARCHAR2:
12102 case STRING:
12103 case UROWID:
12104 case VARRAY:
12105 case VARYING:
12106 case BFILE:
12107 case BLOB:
12108 case CLOB:
12109 case NCLOB:
12110 case YEAR:
12111 case LOCAL:
12112 case WITH:
12113 case ZONE:
12114 case CHARACTER:
12115 case AFTER:
12116 case BEFORE:
12117 case OLD:
12118 case PARENT:
12119 case CC_IF:
12120 case CC_ERROR:
12121 case ANALYZE:
12122 case ASSOCIATE:
12123 case AUDIT:
12124 case COMPOUND:
12125 case DATABASE:
12126 case CALL:
12127 case DDL:
12128 case DISASSOCIATE:
12129 case EACH:
12130 case FOLLOWS:
12131 case LOGOFF:
12132 case LOGON:
12133 case NESTED:
12134 case NOAUDIT:
12135 case SCHEMA:
12136 case SERVERERROR:
12137 case SHUTDOWN:
12138 case STARTUP:
12139 case STATEMENT:
12140 case STATISTICS:
12141 case SUSPEND:
12142 case TRUNCATE:
12143 case WRAPPED:
12144 case LIBRARY:
12145 case NAME:
12146 case STRUCT:
12147 case CONTEXT:
12148 case PARAMETERS:
12149 case LENGTH:
12150 case TDO:
12151 case MAXLEN:
12152 case CHARSETID:
12153 case CHARSETFORM:
12154 case ACCEPT:
12155 case ACCESSIBLE:
12156 case COPY:
12157 case DEFINE:
12158 case DISCONNECT:
12159 case HOST:
12160 case PRINT:
12161 case QUIT:
12162 case REMARK:
12163 case UNDEFINE:
12164 case VARIABLE:
12165 case WHENEVER:
12166 case ATTACH:
12167 case CAST:
12168 case TREAT:
12169 case TRIM:
12170 case LEFT:
12171 case RIGHT:
12172 case BOTH:
12173 case EMPTY:
12174 case MULTISET:
12175 case SUBMULTISET:
12176 case LEADING:
12177 case TRAILING:
12178 case CHAR_CS:
12179 case NCHAR_CS:
12180 case DBTIMEZONE:
12181 case SESSIONTIMEZONE:
12182 case AUTHENTICATED:
12183 case LINK:
12184 case SHARED:
12185 case DIRECTORY:
12186 case USER:
12187 case IDENTIFIER:
12188 case UNSIGNED_NUMERIC_LITERAL:
12189 case CHARACTER_LITERAL:
12190 case STRING_LITERAL:
12191 case QUOTED_LITERAL:
12192 ;
12193 break;
12194 default:
12195 jj_la1[137] = jj_gen;
12196 break label_31;
12197 }
12198 }
12199 jj_consume_token(END);
12200 jj_consume_token(LOOP);
12201 switch (jj_nt.kind) {
12202 case IDENTIFIER:
12203 jj_consume_token(IDENTIFIER);
12204 break;
12205 default:
12206 jj_la1[138] = jj_gen;
12207 ;
12208 }
12209 jjtree.closeNodeScope(jjtn000, true);
12210 jjtc000 = false;
12211 {if (true) return jjtn000 ;}
12212 } catch (Throwable jjte000) {
12213 if (jjtc000) {
12214 jjtree.clearNodeScope(jjtn000);
12215 jjtc000 = false;
12216 } else {
12217 jjtree.popNode();
12218 }
12219 if (jjte000 instanceof RuntimeException) {
12220 {if (true) throw (RuntimeException)jjte000;}
12221 }
12222 if (jjte000 instanceof ParseException) {
12223 {if (true) throw (ParseException)jjte000;}
12224 }
12225 {if (true) throw (Error)jjte000;}
12226 } finally {
12227 if (jjtc000) {
12228 jjtree.closeNodeScope(jjtn000, true);
12229 }
12230 }
12231 throw new Error("Missing return statement in function");
12232 }
12233
12234 final public ASTIfStatement IfStatement() throws ParseException {
12235
12236 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12237 boolean jjtc000 = true;
12238 jjtree.openNodeScope(jjtn000);
12239 try {
12240 jj_consume_token(IF);
12241 Expression();
12242 jj_consume_token(THEN);
12243 label_32:
12244 while (true) {
12245 Statement();
12246 switch (jj_nt.kind) {
12247 case 5:
12248 case 16:
12249 case 17:
12250 case 21:
12251 case REPLACE:
12252 case DEFINER:
12253 case CURRENT_USER:
12254 case LANGUAGE:
12255 case INLINE:
12256 case ADD:
12257 case AGGREGATE:
12258 case ARRAY:
12259 case AT:
12260 case ATTRIBUTE:
12261 case AUTHID:
12262 case BEGIN:
12263 case BODY:
12264 case BULK:
12265 case BYTE:
12266 case CASCADE:
12267 case CASE:
12268 case CLOSE:
12269 case COALESCE:
12270 case COLLECT:
12271 case COLUMN:
12272 case COMMENT:
12273 case COMMIT:
12274 case CONSTRUCTOR:
12275 case CONTINUE:
12276 case CONVERT:
12277 case CURRENT:
12278 case CURSOR:
12279 case DATA:
12280 case DATE:
12281 case DAY:
12282 case DECLARE:
12283 case DELETE:
12284 case DISABLE:
12285 case EDITIONABLE:
12286 case ELEMENT:
12287 case ENABLE:
12288 case ESCAPE:
12289 case EXCEPT:
12290 case EXCEPTIONS:
12291 case EXECUTE:
12292 case EXIT:
12293 case EXTERNAL:
12294 case EXTENDS:
12295 case EXTRACT:
12296 case FALSE:
12297 case FETCH:
12298 case FINAL:
12299 case FOR:
12300 case FORALL:
12301 case FORCE:
12302 case FUNCTION:
12303 case GLOBAL:
12304 case GOTO:
12305 case HASH:
12306 case HEAP:
12307 case HOUR:
12308 case IF:
12309 case IMMEDIATE:
12310 case INDICES:
12311 case INDEXTYPE:
12312 case INDICATOR:
12313 case INSERT:
12314 case INSTANTIABLE:
12315 case INTERVAL:
12316 case INVALIDATE:
12317 case ISOLATION:
12318 case JAVA:
12319 case LEVEL:
12320 case LIMIT:
12321 case LOCK:
12322 case LOOP:
12323 case MAP:
12324 case MAX:
12325 case MEMBER:
12326 case MERGE:
12327 case MIN:
12328 case MINUTE:
12329 case MLSLABEL:
12330 case MODIFY:
12331 case MOD:
12332 case MONTH:
12333 case NATURAL:
12334 case NEW:
12335 case NEW_DOT:
12336 case NO:
12337 case NONEDITIONABLE:
12338 case NOT:
12339 case NULL:
12340 case NULLIF:
12341 case OBJECT:
12342 case OID:
12343 case OPAQUE:
12344 case OPEN:
12345 case OPERATOR:
12346 case ORGANIZATION:
12347 case OTHERS:
12348 case OVERRIDING:
12349 case PACKAGE:
12350 case PARTITION:
12351 case PIPE:
12352 case PRAGMA:
12353 case PRESERVE:
12354 case PRIVATE:
12355 case PROCEDURE:
12356 case RAISE:
12357 case RANGE:
12358 case RAW:
12359 case REAL:
12360 case RECORD:
12361 case REF:
12362 case RELEASE:
12363 case RELIES_ON:
12364 case RENAME:
12365 case RESULT:
12366 case RETURN:
12367 case RETURNING:
12368 case REVERSE:
12369 case ROLLBACK:
12370 case ROW:
12371 case ROWS:
12372 case ROWID:
12373 case ROWNUM:
12374 case SAVE:
12375 case SAVEPOINT:
12376 case SECOND:
12377 case SELECT:
12378 case SELF:
12379 case SET:
12380 case SPACE:
12381 case SQL:
12382 case SQLCODE:
12383 case SQLERRM:
12384 case STATIC:
12385 case SUBTYPE:
12386 case SUBSTITUTABLE:
12387 case SUCCESSFUL:
12388 case SYSDATE:
12389 case SYS_REFCURSOR:
12390 case TEMPORARY:
12391 case TIME:
12392 case TIMESTAMP:
12393 case TIMEZONE_REGION:
12394 case TIMEZONE_ABBR:
12395 case TIMEZONE_MINUTE:
12396 case TIMEZONE_HOUR:
12397 case TRANSACTION:
12398 case TRUE:
12399 case TYPE:
12400 case UNDER:
12401 case USING:
12402 case WHILE:
12403 case YES:
12404 case SHOW:
12405 case A:
12406 case UPDATE:
12407 case DOUBLE:
12408 case DEC:
12409 case PRECISION:
12410 case INT:
12411 case NUMERIC:
12412 case NCHAR:
12413 case NVARCHAR2:
12414 case STRING:
12415 case UROWID:
12416 case VARRAY:
12417 case VARYING:
12418 case BFILE:
12419 case BLOB:
12420 case CLOB:
12421 case NCLOB:
12422 case YEAR:
12423 case LOCAL:
12424 case WITH:
12425 case ZONE:
12426 case CHARACTER:
12427 case AFTER:
12428 case BEFORE:
12429 case OLD:
12430 case PARENT:
12431 case CC_IF:
12432 case CC_ERROR:
12433 case ANALYZE:
12434 case ASSOCIATE:
12435 case AUDIT:
12436 case COMPOUND:
12437 case DATABASE:
12438 case CALL:
12439 case DDL:
12440 case DISASSOCIATE:
12441 case EACH:
12442 case FOLLOWS:
12443 case LOGOFF:
12444 case LOGON:
12445 case NESTED:
12446 case NOAUDIT:
12447 case SCHEMA:
12448 case SERVERERROR:
12449 case SHUTDOWN:
12450 case STARTUP:
12451 case STATEMENT:
12452 case STATISTICS:
12453 case SUSPEND:
12454 case TRUNCATE:
12455 case WRAPPED:
12456 case LIBRARY:
12457 case NAME:
12458 case STRUCT:
12459 case CONTEXT:
12460 case PARAMETERS:
12461 case LENGTH:
12462 case TDO:
12463 case MAXLEN:
12464 case CHARSETID:
12465 case CHARSETFORM:
12466 case ACCEPT:
12467 case ACCESSIBLE:
12468 case COPY:
12469 case DEFINE:
12470 case DISCONNECT:
12471 case HOST:
12472 case PRINT:
12473 case QUIT:
12474 case REMARK:
12475 case UNDEFINE:
12476 case VARIABLE:
12477 case WHENEVER:
12478 case ATTACH:
12479 case CAST:
12480 case TREAT:
12481 case TRIM:
12482 case LEFT:
12483 case RIGHT:
12484 case BOTH:
12485 case EMPTY:
12486 case MULTISET:
12487 case SUBMULTISET:
12488 case LEADING:
12489 case TRAILING:
12490 case CHAR_CS:
12491 case NCHAR_CS:
12492 case DBTIMEZONE:
12493 case SESSIONTIMEZONE:
12494 case AUTHENTICATED:
12495 case LINK:
12496 case SHARED:
12497 case DIRECTORY:
12498 case USER:
12499 case IDENTIFIER:
12500 case UNSIGNED_NUMERIC_LITERAL:
12501 case CHARACTER_LITERAL:
12502 case STRING_LITERAL:
12503 case QUOTED_LITERAL:
12504 ;
12505 break;
12506 default:
12507 jj_la1[139] = jj_gen;
12508 break label_32;
12509 }
12510 }
12511 label_33:
12512 while (true) {
12513 switch (jj_nt.kind) {
12514 case ELSIF:
12515 ;
12516 break;
12517 default:
12518 jj_la1[140] = jj_gen;
12519 break label_33;
12520 }
12521 ElsifClause();
12522 jjtn000.setHasElse();
12523 }
12524 switch (jj_nt.kind) {
12525 case ELSE:
12526 ElseClause();
12527 jjtn000.setHasElse();
12528 break;
12529 default:
12530 jj_la1[141] = jj_gen;
12531 ;
12532 }
12533 jj_consume_token(END);
12534 jj_consume_token(IF);
12535 jjtree.closeNodeScope(jjtn000, true);
12536 jjtc000 = false;
12537 {if (true) return jjtn000 ;}
12538 } catch (Throwable jjte000) {
12539 if (jjtc000) {
12540 jjtree.clearNodeScope(jjtn000);
12541 jjtc000 = false;
12542 } else {
12543 jjtree.popNode();
12544 }
12545 if (jjte000 instanceof RuntimeException) {
12546 {if (true) throw (RuntimeException)jjte000;}
12547 }
12548 if (jjte000 instanceof ParseException) {
12549 {if (true) throw (ParseException)jjte000;}
12550 }
12551 {if (true) throw (Error)jjte000;}
12552 } finally {
12553 if (jjtc000) {
12554 jjtree.closeNodeScope(jjtn000, true);
12555 }
12556 }
12557 throw new Error("Missing return statement in function");
12558 }
12559
12560
12561
12562
12563
12564 final public ASTForIndex ForIndex() throws ParseException {
12565
12566 ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12567 boolean jjtc000 = true;
12568 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12569 try {
12570 simpleNode = ID();
12571 jjtree.closeNodeScope(jjtn000, true);
12572 jjtc000 = false;
12573 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12574 } catch (Throwable jjte000) {
12575 if (jjtc000) {
12576 jjtree.clearNodeScope(jjtn000);
12577 jjtc000 = false;
12578 } else {
12579 jjtree.popNode();
12580 }
12581 if (jjte000 instanceof RuntimeException) {
12582 {if (true) throw (RuntimeException)jjte000;}
12583 }
12584 if (jjte000 instanceof ParseException) {
12585 {if (true) throw (ParseException)jjte000;}
12586 }
12587 {if (true) throw (Error)jjte000;}
12588 } finally {
12589 if (jjtc000) {
12590 jjtree.closeNodeScope(jjtn000, true);
12591 }
12592 }
12593 throw new Error("Missing return statement in function");
12594 }
12595
12596
12597
12598
12599 final public ASTForAllIndex ForAllIndex() throws ParseException {
12600
12601 ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12602 boolean jjtc000 = true;
12603 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12604 try {
12605 simpleNode = ID();
12606 jjtree.closeNodeScope(jjtn000, true);
12607 jjtc000 = false;
12608 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12609 } catch (Throwable jjte000) {
12610 if (jjtc000) {
12611 jjtree.clearNodeScope(jjtn000);
12612 jjtc000 = false;
12613 } else {
12614 jjtree.popNode();
12615 }
12616 if (jjte000 instanceof RuntimeException) {
12617 {if (true) throw (RuntimeException)jjte000;}
12618 }
12619 if (jjte000 instanceof ParseException) {
12620 {if (true) throw (ParseException)jjte000;}
12621 }
12622 {if (true) throw (Error)jjte000;}
12623 } finally {
12624 if (jjtc000) {
12625 jjtree.closeNodeScope(jjtn000, true);
12626 }
12627 }
12628 throw new Error("Missing return statement in function");
12629 }
12630
12631 final public ASTForAllStatement ForAllStatement() throws ParseException {
12632
12633 ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12634 boolean jjtc000 = true;
12635 jjtree.openNodeScope(jjtn000);
12636 try {
12637 jj_consume_token(FORALL);
12638 ForAllIndex();
12639 jj_consume_token(IN);
12640 switch (jj_nt.kind) {
12641 case INDICES:
12642 case VALUES:
12643 switch (jj_nt.kind) {
12644 case INDICES:
12645 jj_consume_token(INDICES);
12646 break;
12647 case VALUES:
12648 jj_consume_token(VALUES);
12649 break;
12650 default:
12651 jj_la1[142] = jj_gen;
12652 jj_consume_token(-1);
12653 throw new ParseException();
12654 }
12655 jj_consume_token(OF);
12656 Expression();
12657 break;
12658 case 5:
12659 case 16:
12660 case 17:
12661 case REPLACE:
12662 case DEFINER:
12663 case CURRENT_USER:
12664 case LANGUAGE:
12665 case INLINE:
12666 case ADD:
12667 case AGGREGATE:
12668 case ARRAY:
12669 case AT:
12670 case ATTRIBUTE:
12671 case AUTHID:
12672 case BODY:
12673 case BULK:
12674 case BYTE:
12675 case CASCADE:
12676 case CASE:
12677 case CLOSE:
12678 case COALESCE:
12679 case COLLECT:
12680 case COLUMN:
12681 case COMMENT:
12682 case COMMIT:
12683 case CONSTRUCTOR:
12684 case CONTINUE:
12685 case CONVERT:
12686 case CURRENT:
12687 case CURSOR:
12688 case DATA:
12689 case DATE:
12690 case DAY:
12691 case DISABLE:
12692 case EDITIONABLE:
12693 case ELEMENT:
12694 case ENABLE:
12695 case ESCAPE:
12696 case EXCEPT:
12697 case EXCEPTIONS:
12698 case EXIT:
12699 case EXTERNAL:
12700 case EXTENDS:
12701 case EXTRACT:
12702 case FALSE:
12703 case FINAL:
12704 case FORCE:
12705 case FUNCTION:
12706 case GLOBAL:
12707 case HASH:
12708 case HEAP:
12709 case HOUR:
12710 case IMMEDIATE:
12711 case INDEXTYPE:
12712 case INDICATOR:
12713 case INSTANTIABLE:
12714 case INTERVAL:
12715 case INVALIDATE:
12716 case ISOLATION:
12717 case JAVA:
12718 case LEVEL:
12719 case LIMIT:
12720 case LOOP:
12721 case MAP:
12722 case MAX:
12723 case MEMBER:
12724 case MERGE:
12725 case MIN:
12726 case MINUTE:
12727 case MLSLABEL:
12728 case MODIFY:
12729 case MOD:
12730 case MONTH:
12731 case NATURAL:
12732 case NEW:
12733 case NEW_DOT:
12734 case NO:
12735 case NONEDITIONABLE:
12736 case NOT:
12737 case NULL:
12738 case NULLIF:
12739 case OBJECT:
12740 case OID:
12741 case OPAQUE:
12742 case OPEN:
12743 case OPERATOR:
12744 case ORGANIZATION:
12745 case OTHERS:
12746 case OVERRIDING:
12747 case PACKAGE:
12748 case PARTITION:
12749 case PRESERVE:
12750 case PRIVATE:
12751 case PROCEDURE:
12752 case RANGE:
12753 case RAW:
12754 case REAL:
12755 case RECORD:
12756 case REF:
12757 case RELEASE:
12758 case RELIES_ON:
12759 case RENAME:
12760 case RESULT:
12761 case RETURN:
12762 case RETURNING:
12763 case REVERSE:
12764 case ROLLBACK:
12765 case ROW:
12766 case ROWS:
12767 case ROWID:
12768 case ROWNUM:
12769 case SAVE:
12770 case SAVEPOINT:
12771 case SECOND:
12772 case SELECT:
12773 case SELF:
12774 case SET:
12775 case SPACE:
12776 case SQL:
12777 case SQLCODE:
12778 case SQLERRM:
12779 case STATIC:
12780 case SUBTYPE:
12781 case SUBSTITUTABLE:
12782 case SUCCESSFUL:
12783 case SYSDATE:
12784 case SYS_REFCURSOR:
12785 case TEMPORARY:
12786 case TIME:
12787 case TIMESTAMP:
12788 case TIMEZONE_REGION:
12789 case TIMEZONE_ABBR:
12790 case TIMEZONE_MINUTE:
12791 case TIMEZONE_HOUR:
12792 case TRANSACTION:
12793 case TRUE:
12794 case TYPE:
12795 case UNDER:
12796 case USING:
12797 case YES:
12798 case SHOW:
12799 case A:
12800 case DOUBLE:
12801 case DEC:
12802 case PRECISION:
12803 case INT:
12804 case NUMERIC:
12805 case NCHAR:
12806 case NVARCHAR2:
12807 case STRING:
12808 case UROWID:
12809 case VARRAY:
12810 case VARYING:
12811 case BFILE:
12812 case BLOB:
12813 case CLOB:
12814 case NCLOB:
12815 case YEAR:
12816 case LOCAL:
12817 case WITH:
12818 case ZONE:
12819 case CHARACTER:
12820 case AFTER:
12821 case BEFORE:
12822 case OLD:
12823 case PARENT:
12824 case CC_IF:
12825 case ANALYZE:
12826 case ASSOCIATE:
12827 case AUDIT:
12828 case COMPOUND:
12829 case DATABASE:
12830 case CALL:
12831 case DDL:
12832 case DISASSOCIATE:
12833 case EACH:
12834 case FOLLOWS:
12835 case LOGOFF:
12836 case LOGON:
12837 case NESTED:
12838 case NOAUDIT:
12839 case SCHEMA:
12840 case SERVERERROR:
12841 case SHUTDOWN:
12842 case STARTUP:
12843 case STATEMENT:
12844 case STATISTICS:
12845 case SUSPEND:
12846 case TRUNCATE:
12847 case WRAPPED:
12848 case LIBRARY:
12849 case NAME:
12850 case STRUCT:
12851 case CONTEXT:
12852 case PARAMETERS:
12853 case LENGTH:
12854 case TDO:
12855 case MAXLEN:
12856 case CHARSETID:
12857 case CHARSETFORM:
12858 case ACCEPT:
12859 case ACCESSIBLE:
12860 case COPY:
12861 case DEFINE:
12862 case DISCONNECT:
12863 case HOST:
12864 case PRINT:
12865 case QUIT:
12866 case REMARK:
12867 case UNDEFINE:
12868 case VARIABLE:
12869 case WHENEVER:
12870 case ATTACH:
12871 case CAST:
12872 case TREAT:
12873 case TRIM:
12874 case LEFT:
12875 case RIGHT:
12876 case BOTH:
12877 case EMPTY:
12878 case MULTISET:
12879 case SUBMULTISET:
12880 case LEADING:
12881 case TRAILING:
12882 case CHAR_CS:
12883 case NCHAR_CS:
12884 case DBTIMEZONE:
12885 case SESSIONTIMEZONE:
12886 case AUTHENTICATED:
12887 case LINK:
12888 case SHARED:
12889 case DIRECTORY:
12890 case USER:
12891 case IDENTIFIER:
12892 case UNSIGNED_NUMERIC_LITERAL:
12893 case CHARACTER_LITERAL:
12894 case STRING_LITERAL:
12895 case QUOTED_LITERAL:
12896 Expression();
12897 switch (jj_nt.kind) {
12898 case 12:
12899 jj_consume_token(12);
12900 Expression();
12901 break;
12902 default:
12903 jj_la1[143] = jj_gen;
12904 ;
12905 }
12906 break;
12907 default:
12908 jj_la1[144] = jj_gen;
12909 jj_consume_token(-1);
12910 throw new ParseException();
12911 }
12912 switch (jj_nt.kind) {
12913 case SAVE:
12914 jj_consume_token(SAVE);
12915 jj_consume_token(EXCEPTIONS);
12916 break;
12917 default:
12918 jj_la1[145] = jj_gen;
12919 ;
12920 }
12921 SqlStatement(null,";");
12922 jjtree.closeNodeScope(jjtn000, true);
12923 jjtc000 = false;
12924 {if (true) return jjtn000 ;}
12925 } catch (Throwable jjte000) {
12926 if (jjtc000) {
12927 jjtree.clearNodeScope(jjtn000);
12928 jjtc000 = false;
12929 } else {
12930 jjtree.popNode();
12931 }
12932 if (jjte000 instanceof RuntimeException) {
12933 {if (true) throw (RuntimeException)jjte000;}
12934 }
12935 if (jjte000 instanceof ParseException) {
12936 {if (true) throw (ParseException)jjte000;}
12937 }
12938 {if (true) throw (Error)jjte000;}
12939 } finally {
12940 if (jjtc000) {
12941 jjtree.closeNodeScope(jjtn000, true);
12942 }
12943 }
12944 throw new Error("Missing return statement in function");
12945 }
12946
12947 final public ASTGotoStatement GotoStatement() throws ParseException {
12948
12949 ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12950 boolean jjtc000 = true;
12951 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12952 try {
12953 jj_consume_token(GOTO);
12954 label = QualifiedName();
12955 jjtree.closeNodeScope(jjtn000, true);
12956 jjtc000 = false;
12957 jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12958 } catch (Throwable jjte000) {
12959 if (jjtc000) {
12960 jjtree.clearNodeScope(jjtn000);
12961 jjtc000 = false;
12962 } else {
12963 jjtree.popNode();
12964 }
12965 if (jjte000 instanceof RuntimeException) {
12966 {if (true) throw (RuntimeException)jjte000;}
12967 }
12968 if (jjte000 instanceof ParseException) {
12969 {if (true) throw (ParseException)jjte000;}
12970 }
12971 {if (true) throw (Error)jjte000;}
12972 } finally {
12973 if (jjtc000) {
12974 jjtree.closeNodeScope(jjtn000, true);
12975 }
12976 }
12977 throw new Error("Missing return statement in function");
12978 }
12979
12980 final public ASTReturnStatement ReturnStatement() throws ParseException {
12981
12982 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12983 boolean jjtc000 = true;
12984 jjtree.openNodeScope(jjtn000);
12985 try {
12986 jj_consume_token(RETURN);
12987 switch (jj_nt.kind) {
12988 case 5:
12989 case 16:
12990 case 17:
12991 case REPLACE:
12992 case DEFINER:
12993 case CURRENT_USER:
12994 case LANGUAGE:
12995 case INLINE:
12996 case ADD:
12997 case AGGREGATE:
12998 case ARRAY:
12999 case AT:
13000 case ATTRIBUTE:
13001 case AUTHID:
13002 case BODY:
13003 case BULK:
13004 case BYTE:
13005 case CASCADE:
13006 case CASE:
13007 case CLOSE:
13008 case COALESCE:
13009 case COLLECT:
13010 case COLUMN:
13011 case COMMENT:
13012 case COMMIT:
13013 case CONSTRUCTOR:
13014 case CONTINUE:
13015 case CONVERT:
13016 case CURRENT:
13017 case CURSOR:
13018 case DATA:
13019 case DATE:
13020 case DAY:
13021 case DISABLE:
13022 case EDITIONABLE:
13023 case ELEMENT:
13024 case ENABLE:
13025 case ESCAPE:
13026 case EXCEPT:
13027 case EXCEPTIONS:
13028 case EXIT:
13029 case EXTERNAL:
13030 case EXTENDS:
13031 case EXTRACT:
13032 case FALSE:
13033 case FINAL:
13034 case FORCE:
13035 case FUNCTION:
13036 case GLOBAL:
13037 case HASH:
13038 case HEAP:
13039 case HOUR:
13040 case IMMEDIATE:
13041 case INDICES:
13042 case INDEXTYPE:
13043 case INDICATOR:
13044 case INSTANTIABLE:
13045 case INTERVAL:
13046 case INVALIDATE:
13047 case ISOLATION:
13048 case JAVA:
13049 case LEVEL:
13050 case LIMIT:
13051 case LOOP:
13052 case MAP:
13053 case MAX:
13054 case MEMBER:
13055 case MERGE:
13056 case MIN:
13057 case MINUTE:
13058 case MLSLABEL:
13059 case MODIFY:
13060 case MOD:
13061 case MONTH:
13062 case NATURAL:
13063 case NEW:
13064 case NEW_DOT:
13065 case NO:
13066 case NONEDITIONABLE:
13067 case NOT:
13068 case NULL:
13069 case NULLIF:
13070 case OBJECT:
13071 case OID:
13072 case OPAQUE:
13073 case OPEN:
13074 case OPERATOR:
13075 case ORGANIZATION:
13076 case OTHERS:
13077 case OVERRIDING:
13078 case PACKAGE:
13079 case PARTITION:
13080 case PRESERVE:
13081 case PRIVATE:
13082 case PROCEDURE:
13083 case RANGE:
13084 case RAW:
13085 case REAL:
13086 case RECORD:
13087 case REF:
13088 case RELEASE:
13089 case RELIES_ON:
13090 case RENAME:
13091 case RESULT:
13092 case RETURN:
13093 case RETURNING:
13094 case REVERSE:
13095 case ROLLBACK:
13096 case ROW:
13097 case ROWS:
13098 case ROWID:
13099 case ROWNUM:
13100 case SAVE:
13101 case SAVEPOINT:
13102 case SECOND:
13103 case SELECT:
13104 case SELF:
13105 case SET:
13106 case SPACE:
13107 case SQL:
13108 case SQLCODE:
13109 case SQLERRM:
13110 case STATIC:
13111 case SUBTYPE:
13112 case SUBSTITUTABLE:
13113 case SUCCESSFUL:
13114 case SYSDATE:
13115 case SYS_REFCURSOR:
13116 case TEMPORARY:
13117 case TIME:
13118 case TIMESTAMP:
13119 case TIMEZONE_REGION:
13120 case TIMEZONE_ABBR:
13121 case TIMEZONE_MINUTE:
13122 case TIMEZONE_HOUR:
13123 case TRANSACTION:
13124 case TRUE:
13125 case TYPE:
13126 case UNDER:
13127 case USING:
13128 case YES:
13129 case SHOW:
13130 case A:
13131 case DOUBLE:
13132 case DEC:
13133 case PRECISION:
13134 case INT:
13135 case NUMERIC:
13136 case NCHAR:
13137 case NVARCHAR2:
13138 case STRING:
13139 case UROWID:
13140 case VARRAY:
13141 case VARYING:
13142 case BFILE:
13143 case BLOB:
13144 case CLOB:
13145 case NCLOB:
13146 case YEAR:
13147 case LOCAL:
13148 case WITH:
13149 case ZONE:
13150 case CHARACTER:
13151 case AFTER:
13152 case BEFORE:
13153 case OLD:
13154 case PARENT:
13155 case CC_IF:
13156 case ANALYZE:
13157 case ASSOCIATE:
13158 case AUDIT:
13159 case COMPOUND:
13160 case DATABASE:
13161 case CALL:
13162 case DDL:
13163 case DISASSOCIATE:
13164 case EACH:
13165 case FOLLOWS:
13166 case LOGOFF:
13167 case LOGON:
13168 case NESTED:
13169 case NOAUDIT:
13170 case SCHEMA:
13171 case SERVERERROR:
13172 case SHUTDOWN:
13173 case STARTUP:
13174 case STATEMENT:
13175 case STATISTICS:
13176 case SUSPEND:
13177 case TRUNCATE:
13178 case WRAPPED:
13179 case LIBRARY:
13180 case NAME:
13181 case STRUCT:
13182 case CONTEXT:
13183 case PARAMETERS:
13184 case LENGTH:
13185 case TDO:
13186 case MAXLEN:
13187 case CHARSETID:
13188 case CHARSETFORM:
13189 case ACCEPT:
13190 case ACCESSIBLE:
13191 case COPY:
13192 case DEFINE:
13193 case DISCONNECT:
13194 case HOST:
13195 case PRINT:
13196 case QUIT:
13197 case REMARK:
13198 case UNDEFINE:
13199 case VARIABLE:
13200 case WHENEVER:
13201 case ATTACH:
13202 case CAST:
13203 case TREAT:
13204 case TRIM:
13205 case LEFT:
13206 case RIGHT:
13207 case BOTH:
13208 case EMPTY:
13209 case MULTISET:
13210 case SUBMULTISET:
13211 case LEADING:
13212 case TRAILING:
13213 case CHAR_CS:
13214 case NCHAR_CS:
13215 case DBTIMEZONE:
13216 case SESSIONTIMEZONE:
13217 case AUTHENTICATED:
13218 case LINK:
13219 case SHARED:
13220 case DIRECTORY:
13221 case USER:
13222 case IDENTIFIER:
13223 case UNSIGNED_NUMERIC_LITERAL:
13224 case CHARACTER_LITERAL:
13225 case STRING_LITERAL:
13226 case QUOTED_LITERAL:
13227 Expression();
13228 break;
13229 default:
13230 jj_la1[146] = jj_gen;
13231 ;
13232 }
13233 jjtree.closeNodeScope(jjtn000, true);
13234 jjtc000 = false;
13235 {if (true) return jjtn000 ;}
13236 } catch (Throwable jjte000) {
13237 if (jjtc000) {
13238 jjtree.clearNodeScope(jjtn000);
13239 jjtc000 = false;
13240 } else {
13241 jjtree.popNode();
13242 }
13243 if (jjte000 instanceof RuntimeException) {
13244 {if (true) throw (RuntimeException)jjte000;}
13245 }
13246 if (jjte000 instanceof ParseException) {
13247 {if (true) throw (ParseException)jjte000;}
13248 }
13249 {if (true) throw (Error)jjte000;}
13250 } finally {
13251 if (jjtc000) {
13252 jjtree.closeNodeScope(jjtn000, true);
13253 }
13254 }
13255 throw new Error("Missing return statement in function");
13256 }
13257
13258 final public ASTContinueStatement ContinueStatement() throws ParseException {
13259
13260 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13261 boolean jjtc000 = true;
13262 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13263 try {
13264 jj_consume_token(CONTINUE);
13265 switch (jj_nt.kind) {
13266 case REPLACE:
13267 case DEFINER:
13268 case CURRENT_USER:
13269 case LANGUAGE:
13270 case INLINE:
13271 case ADD:
13272 case AGGREGATE:
13273 case ARRAY:
13274 case AT:
13275 case ATTRIBUTE:
13276 case AUTHID:
13277 case BODY:
13278 case BULK:
13279 case BYTE:
13280 case CASCADE:
13281 case CLOSE:
13282 case COALESCE:
13283 case COLLECT:
13284 case COLUMN:
13285 case COMMENT:
13286 case COMMIT:
13287 case CONSTRUCTOR:
13288 case CONTINUE:
13289 case CONVERT:
13290 case CURRENT:
13291 case CURSOR:
13292 case DATA:
13293 case DAY:
13294 case DISABLE:
13295 case EDITIONABLE:
13296 case ELEMENT:
13297 case ENABLE:
13298 case ESCAPE:
13299 case EXCEPT:
13300 case EXCEPTIONS:
13301 case EXIT:
13302 case EXTERNAL:
13303 case EXTENDS:
13304 case EXTRACT:
13305 case FALSE:
13306 case FINAL:
13307 case FORCE:
13308 case FUNCTION:
13309 case GLOBAL:
13310 case HASH:
13311 case HEAP:
13312 case HOUR:
13313 case IMMEDIATE:
13314 case INDICES:
13315 case INDEXTYPE:
13316 case INDICATOR:
13317 case INSTANTIABLE:
13318 case INTERVAL:
13319 case INVALIDATE:
13320 case ISOLATION:
13321 case JAVA:
13322 case LEVEL:
13323 case LIMIT:
13324 case LOOP:
13325 case MAP:
13326 case MAX:
13327 case MEMBER:
13328 case MERGE:
13329 case MIN:
13330 case MINUTE:
13331 case MLSLABEL:
13332 case MODIFY:
13333 case MOD:
13334 case MONTH:
13335 case NATURAL:
13336 case NEW:
13337 case NO:
13338 case NONEDITIONABLE:
13339 case NULLIF:
13340 case OBJECT:
13341 case OID:
13342 case OPAQUE:
13343 case OPEN:
13344 case OPERATOR:
13345 case ORGANIZATION:
13346 case OTHERS:
13347 case OVERRIDING:
13348 case PACKAGE:
13349 case PARTITION:
13350 case PRESERVE:
13351 case PRIVATE:
13352 case PROCEDURE:
13353 case RANGE:
13354 case RAW:
13355 case REAL:
13356 case RECORD:
13357 case REF:
13358 case RELEASE:
13359 case RELIES_ON:
13360 case RENAME:
13361 case RESULT:
13362 case RETURN:
13363 case RETURNING:
13364 case REVERSE:
13365 case ROLLBACK:
13366 case ROW:
13367 case ROWS:
13368 case ROWID:
13369 case ROWNUM:
13370 case SAVE:
13371 case SAVEPOINT:
13372 case SECOND:
13373 case SELF:
13374 case SET:
13375 case SPACE:
13376 case SQL:
13377 case SQLCODE:
13378 case SQLERRM:
13379 case STATIC:
13380 case SUBTYPE:
13381 case SUBSTITUTABLE:
13382 case SUCCESSFUL:
13383 case SYSDATE:
13384 case SYS_REFCURSOR:
13385 case TEMPORARY:
13386 case TIME:
13387 case TIMESTAMP:
13388 case TIMEZONE_REGION:
13389 case TIMEZONE_ABBR:
13390 case TIMEZONE_MINUTE:
13391 case TIMEZONE_HOUR:
13392 case TRANSACTION:
13393 case TRUE:
13394 case TYPE:
13395 case UNDER:
13396 case USING:
13397 case YES:
13398 case SHOW:
13399 case A:
13400 case DOUBLE:
13401 case DEC:
13402 case PRECISION:
13403 case INT:
13404 case NUMERIC:
13405 case NCHAR:
13406 case NVARCHAR2:
13407 case STRING:
13408 case UROWID:
13409 case VARRAY:
13410 case VARYING:
13411 case BFILE:
13412 case BLOB:
13413 case CLOB:
13414 case NCLOB:
13415 case YEAR:
13416 case LOCAL:
13417 case ZONE:
13418 case CHARACTER:
13419 case AFTER:
13420 case BEFORE:
13421 case OLD:
13422 case PARENT:
13423 case ANALYZE:
13424 case ASSOCIATE:
13425 case AUDIT:
13426 case COMPOUND:
13427 case DATABASE:
13428 case CALL:
13429 case DDL:
13430 case DISASSOCIATE:
13431 case EACH:
13432 case FOLLOWS:
13433 case LOGOFF:
13434 case LOGON:
13435 case NESTED:
13436 case NOAUDIT:
13437 case SCHEMA:
13438 case SERVERERROR:
13439 case SHUTDOWN:
13440 case STARTUP:
13441 case STATEMENT:
13442 case STATISTICS:
13443 case SUSPEND:
13444 case TRUNCATE:
13445 case WRAPPED:
13446 case LIBRARY:
13447 case NAME:
13448 case STRUCT:
13449 case CONTEXT:
13450 case PARAMETERS:
13451 case LENGTH:
13452 case TDO:
13453 case MAXLEN:
13454 case CHARSETID:
13455 case CHARSETFORM:
13456 case ACCEPT:
13457 case ACCESSIBLE:
13458 case COPY:
13459 case DEFINE:
13460 case DISCONNECT:
13461 case HOST:
13462 case PRINT:
13463 case QUIT:
13464 case REMARK:
13465 case UNDEFINE:
13466 case VARIABLE:
13467 case WHENEVER:
13468 case ATTACH:
13469 case CAST:
13470 case TREAT:
13471 case TRIM:
13472 case LEFT:
13473 case RIGHT:
13474 case BOTH:
13475 case EMPTY:
13476 case MULTISET:
13477 case SUBMULTISET:
13478 case LEADING:
13479 case TRAILING:
13480 case CHAR_CS:
13481 case NCHAR_CS:
13482 case DBTIMEZONE:
13483 case SESSIONTIMEZONE:
13484 case AUTHENTICATED:
13485 case LINK:
13486 case SHARED:
13487 case DIRECTORY:
13488 case USER:
13489 case IDENTIFIER:
13490 case QUOTED_LITERAL:
13491 label = UnqualifiedID();
13492 break;
13493 default:
13494 jj_la1[147] = jj_gen;
13495 ;
13496 }
13497 switch (jj_nt.kind) {
13498 case WHEN:
13499 jj_consume_token(WHEN);
13500 Expression();
13501 break;
13502 default:
13503 jj_la1[148] = jj_gen;
13504 ;
13505 }
13506 jjtree.closeNodeScope(jjtn000, true);
13507 jjtc000 = false;
13508 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13509 } catch (Throwable jjte000) {
13510 if (jjtc000) {
13511 jjtree.clearNodeScope(jjtn000);
13512 jjtc000 = false;
13513 } else {
13514 jjtree.popNode();
13515 }
13516 if (jjte000 instanceof RuntimeException) {
13517 {if (true) throw (RuntimeException)jjte000;}
13518 }
13519 if (jjte000 instanceof ParseException) {
13520 {if (true) throw (ParseException)jjte000;}
13521 }
13522 {if (true) throw (Error)jjte000;}
13523 } finally {
13524 if (jjtc000) {
13525 jjtree.closeNodeScope(jjtn000, true);
13526 }
13527 }
13528 throw new Error("Missing return statement in function");
13529 }
13530
13531 final public ASTExitStatement ExitStatement() throws ParseException {
13532
13533 ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13534 boolean jjtc000 = true;
13535 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13536 try {
13537 jj_consume_token(EXIT);
13538 switch (jj_nt.kind) {
13539 case REPLACE:
13540 case DEFINER:
13541 case CURRENT_USER:
13542 case LANGUAGE:
13543 case INLINE:
13544 case ADD:
13545 case AGGREGATE:
13546 case ARRAY:
13547 case AT:
13548 case ATTRIBUTE:
13549 case AUTHID:
13550 case BODY:
13551 case BULK:
13552 case BYTE:
13553 case CASCADE:
13554 case CLOSE:
13555 case COALESCE:
13556 case COLLECT:
13557 case COLUMN:
13558 case COMMENT:
13559 case COMMIT:
13560 case CONSTRUCTOR:
13561 case CONTINUE:
13562 case CONVERT:
13563 case CURRENT:
13564 case CURSOR:
13565 case DATA:
13566 case DAY:
13567 case DISABLE:
13568 case EDITIONABLE:
13569 case ELEMENT:
13570 case ENABLE:
13571 case ESCAPE:
13572 case EXCEPT:
13573 case EXCEPTIONS:
13574 case EXIT:
13575 case EXTERNAL:
13576 case EXTENDS:
13577 case EXTRACT:
13578 case FALSE:
13579 case FINAL:
13580 case FORCE:
13581 case FUNCTION:
13582 case GLOBAL:
13583 case HASH:
13584 case HEAP:
13585 case HOUR:
13586 case IMMEDIATE:
13587 case INDICES:
13588 case INDEXTYPE:
13589 case INDICATOR:
13590 case INSTANTIABLE:
13591 case INTERVAL:
13592 case INVALIDATE:
13593 case ISOLATION:
13594 case JAVA:
13595 case LEVEL:
13596 case LIMIT:
13597 case LOOP:
13598 case MAP:
13599 case MAX:
13600 case MEMBER:
13601 case MERGE:
13602 case MIN:
13603 case MINUTE:
13604 case MLSLABEL:
13605 case MODIFY:
13606 case MOD:
13607 case MONTH:
13608 case NATURAL:
13609 case NEW:
13610 case NO:
13611 case NONEDITIONABLE:
13612 case NULLIF:
13613 case OBJECT:
13614 case OID:
13615 case OPAQUE:
13616 case OPEN:
13617 case OPERATOR:
13618 case ORGANIZATION:
13619 case OTHERS:
13620 case OVERRIDING:
13621 case PACKAGE:
13622 case PARTITION:
13623 case PRESERVE:
13624 case PRIVATE:
13625 case PROCEDURE:
13626 case RANGE:
13627 case RAW:
13628 case REAL:
13629 case RECORD:
13630 case REF:
13631 case RELEASE:
13632 case RELIES_ON:
13633 case RENAME:
13634 case RESULT:
13635 case RETURN:
13636 case RETURNING:
13637 case REVERSE:
13638 case ROLLBACK:
13639 case ROW:
13640 case ROWS:
13641 case ROWID:
13642 case ROWNUM:
13643 case SAVE:
13644 case SAVEPOINT:
13645 case SECOND:
13646 case SELF:
13647 case SET:
13648 case SPACE:
13649 case SQL:
13650 case SQLCODE:
13651 case SQLERRM:
13652 case STATIC:
13653 case SUBTYPE:
13654 case SUBSTITUTABLE:
13655 case SUCCESSFUL:
13656 case SYSDATE:
13657 case SYS_REFCURSOR:
13658 case TEMPORARY:
13659 case TIME:
13660 case TIMESTAMP:
13661 case TIMEZONE_REGION:
13662 case TIMEZONE_ABBR:
13663 case TIMEZONE_MINUTE:
13664 case TIMEZONE_HOUR:
13665 case TRANSACTION:
13666 case TRUE:
13667 case TYPE:
13668 case UNDER:
13669 case USING:
13670 case YES:
13671 case SHOW:
13672 case A:
13673 case DOUBLE:
13674 case DEC:
13675 case PRECISION:
13676 case INT:
13677 case NUMERIC:
13678 case NCHAR:
13679 case NVARCHAR2:
13680 case STRING:
13681 case UROWID:
13682 case VARRAY:
13683 case VARYING:
13684 case BFILE:
13685 case BLOB:
13686 case CLOB:
13687 case NCLOB:
13688 case YEAR:
13689 case LOCAL:
13690 case ZONE:
13691 case CHARACTER:
13692 case AFTER:
13693 case BEFORE:
13694 case OLD:
13695 case PARENT:
13696 case ANALYZE:
13697 case ASSOCIATE:
13698 case AUDIT:
13699 case COMPOUND:
13700 case DATABASE:
13701 case CALL:
13702 case DDL:
13703 case DISASSOCIATE:
13704 case EACH:
13705 case FOLLOWS:
13706 case LOGOFF:
13707 case LOGON:
13708 case NESTED:
13709 case NOAUDIT:
13710 case SCHEMA:
13711 case SERVERERROR:
13712 case SHUTDOWN:
13713 case STARTUP:
13714 case STATEMENT:
13715 case STATISTICS:
13716 case SUSPEND:
13717 case TRUNCATE:
13718 case WRAPPED:
13719 case LIBRARY:
13720 case NAME:
13721 case STRUCT:
13722 case CONTEXT:
13723 case PARAMETERS:
13724 case LENGTH:
13725 case TDO:
13726 case MAXLEN:
13727 case CHARSETID:
13728 case CHARSETFORM:
13729 case ACCEPT:
13730 case ACCESSIBLE:
13731 case COPY:
13732 case DEFINE:
13733 case DISCONNECT:
13734 case HOST:
13735 case PRINT:
13736 case QUIT:
13737 case REMARK:
13738 case UNDEFINE:
13739 case VARIABLE:
13740 case WHENEVER:
13741 case ATTACH:
13742 case CAST:
13743 case TREAT:
13744 case TRIM:
13745 case LEFT:
13746 case RIGHT:
13747 case BOTH:
13748 case EMPTY:
13749 case MULTISET:
13750 case SUBMULTISET:
13751 case LEADING:
13752 case TRAILING:
13753 case CHAR_CS:
13754 case NCHAR_CS:
13755 case DBTIMEZONE:
13756 case SESSIONTIMEZONE:
13757 case AUTHENTICATED:
13758 case LINK:
13759 case SHARED:
13760 case DIRECTORY:
13761 case USER:
13762 case IDENTIFIER:
13763 case QUOTED_LITERAL:
13764 label = UnqualifiedID();
13765 break;
13766 default:
13767 jj_la1[149] = jj_gen;
13768 ;
13769 }
13770 switch (jj_nt.kind) {
13771 case WHEN:
13772 jj_consume_token(WHEN);
13773 Expression();
13774 break;
13775 default:
13776 jj_la1[150] = jj_gen;
13777 ;
13778 }
13779 jjtree.closeNodeScope(jjtn000, true);
13780 jjtc000 = false;
13781 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13782 } catch (Throwable jjte000) {
13783 if (jjtc000) {
13784 jjtree.clearNodeScope(jjtn000);
13785 jjtc000 = false;
13786 } else {
13787 jjtree.popNode();
13788 }
13789 if (jjte000 instanceof RuntimeException) {
13790 {if (true) throw (RuntimeException)jjte000;}
13791 }
13792 if (jjte000 instanceof ParseException) {
13793 {if (true) throw (ParseException)jjte000;}
13794 }
13795 {if (true) throw (Error)jjte000;}
13796 } finally {
13797 if (jjtc000) {
13798 jjtree.closeNodeScope(jjtn000, true);
13799 }
13800 }
13801 throw new Error("Missing return statement in function");
13802 }
13803
13804 final public ASTRaiseStatement RaiseStatement() throws ParseException {
13805
13806 ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13807 boolean jjtc000 = true;
13808 jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13809 try {
13810 jj_consume_token(RAISE);
13811 switch (jj_nt.kind) {
13812 case REPLACE:
13813 case DEFINER:
13814 case CURRENT_USER:
13815 case LANGUAGE:
13816 case INLINE:
13817 case ADD:
13818 case AGGREGATE:
13819 case ARRAY:
13820 case AT:
13821 case ATTRIBUTE:
13822 case AUTHID:
13823 case BODY:
13824 case BULK:
13825 case BYTE:
13826 case CASCADE:
13827 case CLOSE:
13828 case COALESCE:
13829 case COLLECT:
13830 case COLUMN:
13831 case COMMENT:
13832 case COMMIT:
13833 case CONSTRUCTOR:
13834 case CONTINUE:
13835 case CONVERT:
13836 case CURRENT:
13837 case CURSOR:
13838 case DATA:
13839 case DAY:
13840 case DISABLE:
13841 case EDITIONABLE:
13842 case ELEMENT:
13843 case ENABLE:
13844 case ESCAPE:
13845 case EXCEPT:
13846 case EXCEPTIONS:
13847 case EXIT:
13848 case EXTERNAL:
13849 case EXTENDS:
13850 case EXTRACT:
13851 case FALSE:
13852 case FINAL:
13853 case FORCE:
13854 case FUNCTION:
13855 case GLOBAL:
13856 case HASH:
13857 case HEAP:
13858 case HOUR:
13859 case IMMEDIATE:
13860 case INDICES:
13861 case INDEXTYPE:
13862 case INDICATOR:
13863 case INSTANTIABLE:
13864 case INTERVAL:
13865 case INVALIDATE:
13866 case ISOLATION:
13867 case JAVA:
13868 case LEVEL:
13869 case LIMIT:
13870 case LOOP:
13871 case MAP:
13872 case MAX:
13873 case MEMBER:
13874 case MERGE:
13875 case MIN:
13876 case MINUTE:
13877 case MLSLABEL:
13878 case MODIFY:
13879 case MOD:
13880 case MONTH:
13881 case NATURAL:
13882 case NEW:
13883 case NO:
13884 case NONEDITIONABLE:
13885 case NULLIF:
13886 case OBJECT:
13887 case OID:
13888 case OPAQUE:
13889 case OPEN:
13890 case OPERATOR:
13891 case ORGANIZATION:
13892 case OTHERS:
13893 case OVERRIDING:
13894 case PACKAGE:
13895 case PARTITION:
13896 case PRESERVE:
13897 case PRIVATE:
13898 case PROCEDURE:
13899 case RANGE:
13900 case RAW:
13901 case REAL:
13902 case RECORD:
13903 case REF:
13904 case RELEASE:
13905 case RELIES_ON:
13906 case RENAME:
13907 case RESULT:
13908 case RETURN:
13909 case RETURNING:
13910 case REVERSE:
13911 case ROLLBACK:
13912 case ROW:
13913 case ROWS:
13914 case ROWID:
13915 case ROWNUM:
13916 case SAVE:
13917 case SAVEPOINT:
13918 case SECOND:
13919 case SELF:
13920 case SET:
13921 case SPACE:
13922 case SQL:
13923 case SQLCODE:
13924 case SQLERRM:
13925 case STATIC:
13926 case SUBTYPE:
13927 case SUBSTITUTABLE:
13928 case SUCCESSFUL:
13929 case SYSDATE:
13930 case SYS_REFCURSOR:
13931 case TEMPORARY:
13932 case TIME:
13933 case TIMESTAMP:
13934 case TIMEZONE_REGION:
13935 case TIMEZONE_ABBR:
13936 case TIMEZONE_MINUTE:
13937 case TIMEZONE_HOUR:
13938 case TRANSACTION:
13939 case TRUE:
13940 case TYPE:
13941 case UNDER:
13942 case USING:
13943 case YES:
13944 case SHOW:
13945 case A:
13946 case DOUBLE:
13947 case DEC:
13948 case PRECISION:
13949 case INT:
13950 case NUMERIC:
13951 case NCHAR:
13952 case NVARCHAR2:
13953 case STRING:
13954 case UROWID:
13955 case VARRAY:
13956 case VARYING:
13957 case BFILE:
13958 case BLOB:
13959 case CLOB:
13960 case NCLOB:
13961 case YEAR:
13962 case LOCAL:
13963 case ZONE:
13964 case CHARACTER:
13965 case AFTER:
13966 case BEFORE:
13967 case OLD:
13968 case PARENT:
13969 case ANALYZE:
13970 case ASSOCIATE:
13971 case AUDIT:
13972 case COMPOUND:
13973 case DATABASE:
13974 case CALL:
13975 case DDL:
13976 case DISASSOCIATE:
13977 case EACH:
13978 case FOLLOWS:
13979 case LOGOFF:
13980 case LOGON:
13981 case NESTED:
13982 case NOAUDIT:
13983 case SCHEMA:
13984 case SERVERERROR:
13985 case SHUTDOWN:
13986 case STARTUP:
13987 case STATEMENT:
13988 case STATISTICS:
13989 case SUSPEND:
13990 case TRUNCATE:
13991 case WRAPPED:
13992 case LIBRARY:
13993 case NAME:
13994 case STRUCT:
13995 case CONTEXT:
13996 case PARAMETERS:
13997 case LENGTH:
13998 case TDO:
13999 case MAXLEN:
14000 case CHARSETID:
14001 case CHARSETFORM:
14002 case ACCEPT:
14003 case ACCESSIBLE:
14004 case COPY:
14005 case DEFINE:
14006 case DISCONNECT:
14007 case HOST:
14008 case PRINT:
14009 case QUIT:
14010 case REMARK:
14011 case UNDEFINE:
14012 case VARIABLE:
14013 case WHENEVER:
14014 case ATTACH:
14015 case CAST:
14016 case TREAT:
14017 case TRIM:
14018 case LEFT:
14019 case RIGHT:
14020 case BOTH:
14021 case EMPTY:
14022 case MULTISET:
14023 case SUBMULTISET:
14024 case LEADING:
14025 case TRAILING:
14026 case CHAR_CS:
14027 case NCHAR_CS:
14028 case DBTIMEZONE:
14029 case SESSIONTIMEZONE:
14030 case AUTHENTICATED:
14031 case LINK:
14032 case SHARED:
14033 case DIRECTORY:
14034 case USER:
14035 case IDENTIFIER:
14036 case QUOTED_LITERAL:
14037 exception = QualifiedName();
14038 break;
14039 default:
14040 jj_la1[151] = jj_gen;
14041 ;
14042 }
14043 jjtree.closeNodeScope(jjtn000, true);
14044 jjtc000 = false;
14045 if (null != exception) { jjtn000.setImage(exception.getImage()) ; } {if (true) return jjtn000 ;}
14046 } catch (Throwable jjte000) {
14047 if (jjtc000) {
14048 jjtree.clearNodeScope(jjtn000);
14049 jjtc000 = false;
14050 } else {
14051 jjtree.popNode();
14052 }
14053 if (jjte000 instanceof RuntimeException) {
14054 {if (true) throw (RuntimeException)jjte000;}
14055 }
14056 if (jjte000 instanceof ParseException) {
14057 {if (true) throw (ParseException)jjte000;}
14058 }
14059 {if (true) throw (Error)jjte000;}
14060 } finally {
14061 if (jjtc000) {
14062 jjtree.closeNodeScope(jjtn000, true);
14063 }
14064 }
14065 throw new Error("Missing return statement in function");
14066 }
14067
14068 final public ASTCloseStatement CloseStatement() throws ParseException {
14069
14070 ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14071 boolean jjtc000 = true;
14072 jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14073 try {
14074 jj_consume_token(CLOSE);
14075 cursor = QualifiedName();
14076 jjtree.closeNodeScope(jjtn000, true);
14077 jjtc000 = false;
14078 jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14079 } catch (Throwable jjte000) {
14080 if (jjtc000) {
14081 jjtree.clearNodeScope(jjtn000);
14082 jjtc000 = false;
14083 } else {
14084 jjtree.popNode();
14085 }
14086 if (jjte000 instanceof RuntimeException) {
14087 {if (true) throw (RuntimeException)jjte000;}
14088 }
14089 if (jjte000 instanceof ParseException) {
14090 {if (true) throw (ParseException)jjte000;}
14091 }
14092 {if (true) throw (Error)jjte000;}
14093 } finally {
14094 if (jjtc000) {
14095 jjtree.closeNodeScope(jjtn000, true);
14096 }
14097 }
14098 throw new Error("Missing return statement in function");
14099 }
14100
14101 final public ASTOpenStatement OpenStatement() throws ParseException {
14102
14103 ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14104 boolean jjtc000 = true;
14105 jjtree.openNodeScope(jjtn000);
14106 try {
14107 jj_consume_token(OPEN);
14108 switch (jj_nt.kind) {
14109 case 5:
14110 case 16:
14111 case 17:
14112 case REPLACE:
14113 case DEFINER:
14114 case CURRENT_USER:
14115 case LANGUAGE:
14116 case INLINE:
14117 case ADD:
14118 case AGGREGATE:
14119 case ARRAY:
14120 case AT:
14121 case ATTRIBUTE:
14122 case AUTHID:
14123 case BODY:
14124 case BULK:
14125 case BYTE:
14126 case CASCADE:
14127 case CASE:
14128 case CLOSE:
14129 case COALESCE:
14130 case COLLECT:
14131 case COLUMN:
14132 case COMMENT:
14133 case COMMIT:
14134 case CONSTRUCTOR:
14135 case CONTINUE:
14136 case CONVERT:
14137 case CURRENT:
14138 case CURSOR:
14139 case DATA:
14140 case DATE:
14141 case DAY:
14142 case DISABLE:
14143 case EDITIONABLE:
14144 case ELEMENT:
14145 case ENABLE:
14146 case ESCAPE:
14147 case EXCEPT:
14148 case EXCEPTIONS:
14149 case EXIT:
14150 case EXTERNAL:
14151 case EXTENDS:
14152 case EXTRACT:
14153 case FALSE:
14154 case FINAL:
14155 case FORCE:
14156 case FUNCTION:
14157 case GLOBAL:
14158 case HASH:
14159 case HEAP:
14160 case HOUR:
14161 case IMMEDIATE:
14162 case INDICES:
14163 case INDEXTYPE:
14164 case INDICATOR:
14165 case INSTANTIABLE:
14166 case INTERVAL:
14167 case INVALIDATE:
14168 case ISOLATION:
14169 case JAVA:
14170 case LEVEL:
14171 case LIMIT:
14172 case LOOP:
14173 case MAP:
14174 case MAX:
14175 case MEMBER:
14176 case MERGE:
14177 case MIN:
14178 case MINUTE:
14179 case MLSLABEL:
14180 case MODIFY:
14181 case MOD:
14182 case MONTH:
14183 case NATURAL:
14184 case NEW:
14185 case NEW_DOT:
14186 case NO:
14187 case NONEDITIONABLE:
14188 case NOT:
14189 case NULL:
14190 case NULLIF:
14191 case OBJECT:
14192 case OID:
14193 case OPAQUE:
14194 case OPEN:
14195 case OPERATOR:
14196 case ORGANIZATION:
14197 case OTHERS:
14198 case OVERRIDING:
14199 case PACKAGE:
14200 case PARTITION:
14201 case PRESERVE:
14202 case PRIVATE:
14203 case PROCEDURE:
14204 case RANGE:
14205 case RAW:
14206 case REAL:
14207 case RECORD:
14208 case REF:
14209 case RELEASE:
14210 case RELIES_ON:
14211 case RENAME:
14212 case RESULT:
14213 case RETURN:
14214 case RETURNING:
14215 case REVERSE:
14216 case ROLLBACK:
14217 case ROW:
14218 case ROWS:
14219 case ROWID:
14220 case ROWNUM:
14221 case SAVE:
14222 case SAVEPOINT:
14223 case SECOND:
14224 case SELECT:
14225 case SELF:
14226 case SET:
14227 case SPACE:
14228 case SQL:
14229 case SQLCODE:
14230 case SQLERRM:
14231 case STATIC:
14232 case SUBTYPE:
14233 case SUBSTITUTABLE:
14234 case SUCCESSFUL:
14235 case SYSDATE:
14236 case SYS_REFCURSOR:
14237 case TEMPORARY:
14238 case TIME:
14239 case TIMESTAMP:
14240 case TIMEZONE_REGION:
14241 case TIMEZONE_ABBR:
14242 case TIMEZONE_MINUTE:
14243 case TIMEZONE_HOUR:
14244 case TRANSACTION:
14245 case TRUE:
14246 case TYPE:
14247 case UNDER:
14248 case USING:
14249 case YES:
14250 case SHOW:
14251 case A:
14252 case DOUBLE:
14253 case DEC:
14254 case PRECISION:
14255 case INT:
14256 case NUMERIC:
14257 case NCHAR:
14258 case NVARCHAR2:
14259 case STRING:
14260 case UROWID:
14261 case VARRAY:
14262 case VARYING:
14263 case BFILE:
14264 case BLOB:
14265 case CLOB:
14266 case NCLOB:
14267 case YEAR:
14268 case LOCAL:
14269 case WITH:
14270 case ZONE:
14271 case CHARACTER:
14272 case AFTER:
14273 case BEFORE:
14274 case OLD:
14275 case PARENT:
14276 case CC_IF:
14277 case ANALYZE:
14278 case ASSOCIATE:
14279 case AUDIT:
14280 case COMPOUND:
14281 case DATABASE:
14282 case CALL:
14283 case DDL:
14284 case DISASSOCIATE:
14285 case EACH:
14286 case FOLLOWS:
14287 case LOGOFF:
14288 case LOGON:
14289 case NESTED:
14290 case NOAUDIT:
14291 case SCHEMA:
14292 case SERVERERROR:
14293 case SHUTDOWN:
14294 case STARTUP:
14295 case STATEMENT:
14296 case STATISTICS:
14297 case SUSPEND:
14298 case TRUNCATE:
14299 case WRAPPED:
14300 case LIBRARY:
14301 case NAME:
14302 case STRUCT:
14303 case CONTEXT:
14304 case PARAMETERS:
14305 case LENGTH:
14306 case TDO:
14307 case MAXLEN:
14308 case CHARSETID:
14309 case CHARSETFORM:
14310 case ACCEPT:
14311 case ACCESSIBLE:
14312 case COPY:
14313 case DEFINE:
14314 case DISCONNECT:
14315 case HOST:
14316 case PRINT:
14317 case QUIT:
14318 case REMARK:
14319 case UNDEFINE:
14320 case VARIABLE:
14321 case WHENEVER:
14322 case ATTACH:
14323 case CAST:
14324 case TREAT:
14325 case TRIM:
14326 case LEFT:
14327 case RIGHT:
14328 case BOTH:
14329 case EMPTY:
14330 case MULTISET:
14331 case SUBMULTISET:
14332 case LEADING:
14333 case TRAILING:
14334 case CHAR_CS:
14335 case NCHAR_CS:
14336 case DBTIMEZONE:
14337 case SESSIONTIMEZONE:
14338 case AUTHENTICATED:
14339 case LINK:
14340 case SHARED:
14341 case DIRECTORY:
14342 case USER:
14343 case IDENTIFIER:
14344 case UNSIGNED_NUMERIC_LITERAL:
14345 case CHARACTER_LITERAL:
14346 case STRING_LITERAL:
14347 case QUOTED_LITERAL:
14348 Expression();
14349 break;
14350 default:
14351 jj_la1[152] = jj_gen;
14352 ;
14353 }
14354 switch (jj_nt.kind) {
14355 case FOR:
14356 jj_consume_token(FOR);
14357 Expression();
14358 switch (jj_nt.kind) {
14359 case USING:
14360 jj_consume_token(USING);
14361 switch (jj_nt.kind) {
14362 case IN:
14363 case IN_OUT:
14364 case OUT:
14365 switch (jj_nt.kind) {
14366 case IN:
14367 jj_consume_token(IN);
14368 break;
14369 case OUT:
14370 jj_consume_token(OUT);
14371 break;
14372 case IN_OUT:
14373 jj_consume_token(IN_OUT);
14374 break;
14375 default:
14376 jj_la1[153] = jj_gen;
14377 jj_consume_token(-1);
14378 throw new ParseException();
14379 }
14380 break;
14381 default:
14382 jj_la1[154] = jj_gen;
14383 ;
14384 }
14385 Expression();
14386 label_34:
14387 while (true) {
14388 switch (jj_nt.kind) {
14389 case 6:
14390 ;
14391 break;
14392 default:
14393 jj_la1[155] = jj_gen;
14394 break label_34;
14395 }
14396 jj_consume_token(6);
14397 switch (jj_nt.kind) {
14398 case IN:
14399 case IN_OUT:
14400 case OUT:
14401 switch (jj_nt.kind) {
14402 case IN:
14403 jj_consume_token(IN);
14404 break;
14405 case OUT:
14406 jj_consume_token(OUT);
14407 break;
14408 case IN_OUT:
14409 jj_consume_token(IN_OUT);
14410 break;
14411 default:
14412 jj_la1[156] = jj_gen;
14413 jj_consume_token(-1);
14414 throw new ParseException();
14415 }
14416 break;
14417 default:
14418 jj_la1[157] = jj_gen;
14419 ;
14420 }
14421 Expression();
14422 }
14423 break;
14424 default:
14425 jj_la1[158] = jj_gen;
14426 ;
14427 }
14428 break;
14429 default:
14430 jj_la1[159] = jj_gen;
14431 ;
14432 }
14433 jjtree.closeNodeScope(jjtn000, true);
14434 jjtc000 = false;
14435 {if (true) return jjtn000 ;}
14436 } catch (Throwable jjte000) {
14437 if (jjtc000) {
14438 jjtree.clearNodeScope(jjtn000);
14439 jjtc000 = false;
14440 } else {
14441 jjtree.popNode();
14442 }
14443 if (jjte000 instanceof RuntimeException) {
14444 {if (true) throw (RuntimeException)jjte000;}
14445 }
14446 if (jjte000 instanceof ParseException) {
14447 {if (true) throw (ParseException)jjte000;}
14448 }
14449 {if (true) throw (Error)jjte000;}
14450 } finally {
14451 if (jjtc000) {
14452 jjtree.closeNodeScope(jjtn000, true);
14453 }
14454 }
14455 throw new Error("Missing return statement in function");
14456 }
14457
14458 final public ASTFetchStatement FetchStatement() throws ParseException {
14459
14460 ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14461 boolean jjtc000 = true;
14462 jjtree.openNodeScope(jjtn000);
14463 try {
14464 jj_consume_token(FETCH);
14465 QualifiedName();
14466 switch (jj_nt.kind) {
14467 case BULK:
14468 jj_consume_token(BULK);
14469 jj_consume_token(COLLECT);
14470 break;
14471 default:
14472 jj_la1[160] = jj_gen;
14473 ;
14474 }
14475 jj_consume_token(INTO);
14476 Expression();
14477 label_35:
14478 while (true) {
14479 switch (jj_nt.kind) {
14480 case 6:
14481 ;
14482 break;
14483 default:
14484 jj_la1[161] = jj_gen;
14485 break label_35;
14486 }
14487 jj_consume_token(6);
14488 Expression();
14489 }
14490 switch (jj_nt.kind) {
14491 case LIMIT:
14492 jj_consume_token(LIMIT);
14493 Expression();
14494 break;
14495 default:
14496 jj_la1[162] = jj_gen;
14497 ;
14498 }
14499 jjtree.closeNodeScope(jjtn000, true);
14500 jjtc000 = false;
14501 {if (true) return jjtn000 ;}
14502 } catch (Throwable jjte000) {
14503 if (jjtc000) {
14504 jjtree.clearNodeScope(jjtn000);
14505 jjtc000 = false;
14506 } else {
14507 jjtree.popNode();
14508 }
14509 if (jjte000 instanceof RuntimeException) {
14510 {if (true) throw (RuntimeException)jjte000;}
14511 }
14512 if (jjte000 instanceof ParseException) {
14513 {if (true) throw (ParseException)jjte000;}
14514 }
14515 {if (true) throw (Error)jjte000;}
14516 } finally {
14517 if (jjtc000) {
14518 jjtree.closeNodeScope(jjtn000, true);
14519 }
14520 }
14521 throw new Error("Missing return statement in function");
14522 }
14523
14524 final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14525
14526 ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14527 boolean jjtc000 = true;
14528 jjtree.openNodeScope(jjtn000);
14529 try {
14530 jj_consume_token(EXECUTE);
14531 jj_consume_token(IMMEDIATE);
14532 Expression();
14533 switch (jj_nt.kind) {
14534 case INTO:
14535 jj_consume_token(INTO);
14536 Name();
14537 label_36:
14538 while (true) {
14539 switch (jj_nt.kind) {
14540 case 6:
14541 ;
14542 break;
14543 default:
14544 jj_la1[163] = jj_gen;
14545 break label_36;
14546 }
14547 jj_consume_token(6);
14548 Name();
14549 }
14550 break;
14551 default:
14552 jj_la1[164] = jj_gen;
14553 ;
14554 }
14555 switch (jj_nt.kind) {
14556 case USING:
14557 jj_consume_token(USING);
14558 switch (jj_nt.kind) {
14559 case IN:
14560 case OUT:
14561 switch (jj_nt.kind) {
14562 case IN:
14563 jj_consume_token(IN);
14564 switch (jj_nt.kind) {
14565 case OUT:
14566 jj_consume_token(OUT);
14567 break;
14568 default:
14569 jj_la1[165] = jj_gen;
14570 ;
14571 }
14572 break;
14573 case OUT:
14574 jj_consume_token(OUT);
14575 break;
14576 default:
14577 jj_la1[166] = jj_gen;
14578 jj_consume_token(-1);
14579 throw new ParseException();
14580 }
14581 break;
14582 default:
14583 jj_la1[167] = jj_gen;
14584 ;
14585 }
14586 Expression();
14587 label_37:
14588 while (true) {
14589 switch (jj_nt.kind) {
14590 case 6:
14591 ;
14592 break;
14593 default:
14594 jj_la1[168] = jj_gen;
14595 break label_37;
14596 }
14597 jj_consume_token(6);
14598 switch (jj_nt.kind) {
14599 case IN:
14600 case OUT:
14601 switch (jj_nt.kind) {
14602 case IN:
14603 jj_consume_token(IN);
14604 switch (jj_nt.kind) {
14605 case OUT:
14606 jj_consume_token(OUT);
14607 break;
14608 default:
14609 jj_la1[169] = jj_gen;
14610 ;
14611 }
14612 break;
14613 case OUT:
14614 jj_consume_token(OUT);
14615 break;
14616 default:
14617 jj_la1[170] = jj_gen;
14618 jj_consume_token(-1);
14619 throw new ParseException();
14620 }
14621 break;
14622 default:
14623 jj_la1[171] = jj_gen;
14624 ;
14625 }
14626 Expression();
14627 }
14628 break;
14629 default:
14630 jj_la1[172] = jj_gen;
14631 ;
14632 }
14633 switch (jj_nt.kind) {
14634 case RETURN:
14635 case RETURNING:
14636 switch (jj_nt.kind) {
14637 case RETURN:
14638 jj_consume_token(RETURN);
14639 break;
14640 case RETURNING:
14641 jj_consume_token(RETURNING);
14642 break;
14643 default:
14644 jj_la1[173] = jj_gen;
14645 jj_consume_token(-1);
14646 throw new ParseException();
14647 }
14648 jj_consume_token(INTO);
14649 Expression();
14650 label_38:
14651 while (true) {
14652 switch (jj_nt.kind) {
14653 case 6:
14654 ;
14655 break;
14656 default:
14657 jj_la1[174] = jj_gen;
14658 break label_38;
14659 }
14660 jj_consume_token(6);
14661 Expression();
14662 }
14663 break;
14664 default:
14665 jj_la1[175] = jj_gen;
14666 ;
14667 }
14668 jj_consume_token(4);
14669 jjtree.closeNodeScope(jjtn000, true);
14670 jjtc000 = false;
14671 {if (true) return jjtn000 ;}
14672 } catch (Throwable jjte000) {
14673 if (jjtc000) {
14674 jjtree.clearNodeScope(jjtn000);
14675 jjtc000 = false;
14676 } else {
14677 jjtree.popNode();
14678 }
14679 if (jjte000 instanceof RuntimeException) {
14680 {if (true) throw (RuntimeException)jjte000;}
14681 }
14682 if (jjte000 instanceof ParseException) {
14683 {if (true) throw (ParseException)jjte000;}
14684 }
14685 {if (true) throw (Error)jjte000;}
14686 } finally {
14687 if (jjtc000) {
14688 jjtree.closeNodeScope(jjtn000, true);
14689 }
14690 }
14691 throw new Error("Missing return statement in function");
14692 }
14693
14694 final public ASTPipelineStatement PipelineStatement() throws ParseException {
14695
14696 ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14697 boolean jjtc000 = true;
14698 jjtree.openNodeScope(jjtn000);
14699 try {
14700 jj_consume_token(PIPE);
14701 jj_consume_token(ROW);
14702 Expression();
14703 jjtree.closeNodeScope(jjtn000, true);
14704 jjtc000 = false;
14705 {if (true) return jjtn000 ;}
14706 } catch (Throwable jjte000) {
14707 if (jjtc000) {
14708 jjtree.clearNodeScope(jjtn000);
14709 jjtc000 = false;
14710 } else {
14711 jjtree.popNode();
14712 }
14713 if (jjte000 instanceof RuntimeException) {
14714 {if (true) throw (RuntimeException)jjte000;}
14715 }
14716 if (jjte000 instanceof ParseException) {
14717 {if (true) throw (ParseException)jjte000;}
14718 }
14719 {if (true) throw (Error)jjte000;}
14720 } finally {
14721 if (jjtc000) {
14722 jjtree.closeNodeScope(jjtn000, true);
14723 }
14724 }
14725 throw new Error("Missing return statement in function");
14726 }
14727
14728 final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14729
14730 ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14731 boolean jjtc000 = true;
14732 jjtree.openNodeScope(jjtn000);
14733 try {
14734 switch (jj_nt.kind) {
14735 case CC_IF:
14736 jj_consume_token(CC_IF);
14737 ConditionalOrExpression();
14738 jj_consume_token(CC_THEN);
14739 label_39:
14740 while (true) {
14741 switch (jj_nt.kind) {
14742 case 5:
14743 case 16:
14744 case 17:
14745 case 21:
14746 case REPLACE:
14747 case DEFINER:
14748 case CURRENT_USER:
14749 case LANGUAGE:
14750 case INLINE:
14751 case ADD:
14752 case AGGREGATE:
14753 case ARRAY:
14754 case AT:
14755 case ATTRIBUTE:
14756 case AUTHID:
14757 case BEGIN:
14758 case BODY:
14759 case BULK:
14760 case BYTE:
14761 case CASCADE:
14762 case CASE:
14763 case CLOSE:
14764 case COALESCE:
14765 case COLLECT:
14766 case COLUMN:
14767 case COMMENT:
14768 case COMMIT:
14769 case CONSTRUCTOR:
14770 case CONTINUE:
14771 case CONVERT:
14772 case CURRENT:
14773 case CURSOR:
14774 case DATA:
14775 case DATE:
14776 case DAY:
14777 case DECLARE:
14778 case DELETE:
14779 case DISABLE:
14780 case EDITIONABLE:
14781 case ELEMENT:
14782 case ENABLE:
14783 case ESCAPE:
14784 case EXCEPT:
14785 case EXCEPTIONS:
14786 case EXECUTE:
14787 case EXIT:
14788 case EXTERNAL:
14789 case EXTENDS:
14790 case EXTRACT:
14791 case FALSE:
14792 case FETCH:
14793 case FINAL:
14794 case FOR:
14795 case FORALL:
14796 case FORCE:
14797 case FUNCTION:
14798 case GLOBAL:
14799 case GOTO:
14800 case HASH:
14801 case HEAP:
14802 case HOUR:
14803 case IF:
14804 case IMMEDIATE:
14805 case INDICES:
14806 case INDEXTYPE:
14807 case INDICATOR:
14808 case INSERT:
14809 case INSTANTIABLE:
14810 case INTERVAL:
14811 case INVALIDATE:
14812 case ISOLATION:
14813 case JAVA:
14814 case LEVEL:
14815 case LIMIT:
14816 case LOCK:
14817 case LOOP:
14818 case MAP:
14819 case MAX:
14820 case MEMBER:
14821 case MERGE:
14822 case MIN:
14823 case MINUTE:
14824 case MLSLABEL:
14825 case MODIFY:
14826 case MOD:
14827 case MONTH:
14828 case NATURAL:
14829 case NEW:
14830 case NEW_DOT:
14831 case NO:
14832 case NONEDITIONABLE:
14833 case NOT:
14834 case NULL:
14835 case NULLIF:
14836 case OBJECT:
14837 case OID:
14838 case OPAQUE:
14839 case OPEN:
14840 case OPERATOR:
14841 case ORGANIZATION:
14842 case OTHERS:
14843 case OVERRIDING:
14844 case PACKAGE:
14845 case PARTITION:
14846 case PIPE:
14847 case PRAGMA:
14848 case PRESERVE:
14849 case PRIVATE:
14850 case PROCEDURE:
14851 case RAISE:
14852 case RANGE:
14853 case RAW:
14854 case REAL:
14855 case RECORD:
14856 case REF:
14857 case RELEASE:
14858 case RELIES_ON:
14859 case RENAME:
14860 case RESULT:
14861 case RETURN:
14862 case RETURNING:
14863 case REVERSE:
14864 case ROLLBACK:
14865 case ROW:
14866 case ROWS:
14867 case ROWID:
14868 case ROWNUM:
14869 case SAVE:
14870 case SAVEPOINT:
14871 case SECOND:
14872 case SELECT:
14873 case SELF:
14874 case SET:
14875 case SPACE:
14876 case SQL:
14877 case SQLCODE:
14878 case SQLERRM:
14879 case STATIC:
14880 case SUBTYPE:
14881 case SUBSTITUTABLE:
14882 case SUCCESSFUL:
14883 case SYSDATE:
14884 case SYS_REFCURSOR:
14885 case TEMPORARY:
14886 case TIME:
14887 case TIMESTAMP:
14888 case TIMEZONE_REGION:
14889 case TIMEZONE_ABBR:
14890 case TIMEZONE_MINUTE:
14891 case TIMEZONE_HOUR:
14892 case TRANSACTION:
14893 case TRUE:
14894 case TYPE:
14895 case UNDER:
14896 case USING:
14897 case WHILE:
14898 case YES:
14899 case SHOW:
14900 case A:
14901 case UPDATE:
14902 case DOUBLE:
14903 case DEC:
14904 case PRECISION:
14905 case INT:
14906 case NUMERIC:
14907 case NCHAR:
14908 case NVARCHAR2:
14909 case STRING:
14910 case UROWID:
14911 case VARRAY:
14912 case VARYING:
14913 case BFILE:
14914 case BLOB:
14915 case CLOB:
14916 case NCLOB:
14917 case YEAR:
14918 case LOCAL:
14919 case WITH:
14920 case ZONE:
14921 case CHARACTER:
14922 case AFTER:
14923 case BEFORE:
14924 case OLD:
14925 case PARENT:
14926 case CC_IF:
14927 case CC_ERROR:
14928 case ANALYZE:
14929 case ASSOCIATE:
14930 case AUDIT:
14931 case COMPOUND:
14932 case DATABASE:
14933 case CALL:
14934 case DDL:
14935 case DISASSOCIATE:
14936 case EACH:
14937 case FOLLOWS:
14938 case LOGOFF:
14939 case LOGON:
14940 case NESTED:
14941 case NOAUDIT:
14942 case SCHEMA:
14943 case SERVERERROR:
14944 case SHUTDOWN:
14945 case STARTUP:
14946 case STATEMENT:
14947 case STATISTICS:
14948 case SUSPEND:
14949 case TRUNCATE:
14950 case WRAPPED:
14951 case LIBRARY:
14952 case NAME:
14953 case STRUCT:
14954 case CONTEXT:
14955 case PARAMETERS:
14956 case LENGTH:
14957 case TDO:
14958 case MAXLEN:
14959 case CHARSETID:
14960 case CHARSETFORM:
14961 case ACCEPT:
14962 case ACCESSIBLE:
14963 case COPY:
14964 case DEFINE:
14965 case DISCONNECT:
14966 case HOST:
14967 case PRINT:
14968 case QUIT:
14969 case REMARK:
14970 case UNDEFINE:
14971 case VARIABLE:
14972 case WHENEVER:
14973 case ATTACH:
14974 case CAST:
14975 case TREAT:
14976 case TRIM:
14977 case LEFT:
14978 case RIGHT:
14979 case BOTH:
14980 case EMPTY:
14981 case MULTISET:
14982 case SUBMULTISET:
14983 case LEADING:
14984 case TRAILING:
14985 case CHAR_CS:
14986 case NCHAR_CS:
14987 case DBTIMEZONE:
14988 case SESSIONTIMEZONE:
14989 case AUTHENTICATED:
14990 case LINK:
14991 case SHARED:
14992 case DIRECTORY:
14993 case USER:
14994 case IDENTIFIER:
14995 case UNSIGNED_NUMERIC_LITERAL:
14996 case CHARACTER_LITERAL:
14997 case STRING_LITERAL:
14998 case QUOTED_LITERAL:
14999 ;
15000 break;
15001 default:
15002 jj_la1[176] = jj_gen;
15003 break label_39;
15004 }
15005 Statement();
15006 }
15007 label_40:
15008 while (true) {
15009 switch (jj_nt.kind) {
15010 case CC_ELSIF:
15011 ;
15012 break;
15013 default:
15014 jj_la1[177] = jj_gen;
15015 break label_40;
15016 }
15017 jj_consume_token(CC_ELSIF);
15018 ConditionalOrExpression();
15019 jj_consume_token(CC_THEN);
15020 label_41:
15021 while (true) {
15022 Statement();
15023 switch (jj_nt.kind) {
15024 case 5:
15025 case 16:
15026 case 17:
15027 case 21:
15028 case REPLACE:
15029 case DEFINER:
15030 case CURRENT_USER:
15031 case LANGUAGE:
15032 case INLINE:
15033 case ADD:
15034 case AGGREGATE:
15035 case ARRAY:
15036 case AT:
15037 case ATTRIBUTE:
15038 case AUTHID:
15039 case BEGIN:
15040 case BODY:
15041 case BULK:
15042 case BYTE:
15043 case CASCADE:
15044 case CASE:
15045 case CLOSE:
15046 case COALESCE:
15047 case COLLECT:
15048 case COLUMN:
15049 case COMMENT:
15050 case COMMIT:
15051 case CONSTRUCTOR:
15052 case CONTINUE:
15053 case CONVERT:
15054 case CURRENT:
15055 case CURSOR:
15056 case DATA:
15057 case DATE:
15058 case DAY:
15059 case DECLARE:
15060 case DELETE:
15061 case DISABLE:
15062 case EDITIONABLE:
15063 case ELEMENT:
15064 case ENABLE:
15065 case ESCAPE:
15066 case EXCEPT:
15067 case EXCEPTIONS:
15068 case EXECUTE:
15069 case EXIT:
15070 case EXTERNAL:
15071 case EXTENDS:
15072 case EXTRACT:
15073 case FALSE:
15074 case FETCH:
15075 case FINAL:
15076 case FOR:
15077 case FORALL:
15078 case FORCE:
15079 case FUNCTION:
15080 case GLOBAL:
15081 case GOTO:
15082 case HASH:
15083 case HEAP:
15084 case HOUR:
15085 case IF:
15086 case IMMEDIATE:
15087 case INDICES:
15088 case INDEXTYPE:
15089 case INDICATOR:
15090 case INSERT:
15091 case INSTANTIABLE:
15092 case INTERVAL:
15093 case INVALIDATE:
15094 case ISOLATION:
15095 case JAVA:
15096 case LEVEL:
15097 case LIMIT:
15098 case LOCK:
15099 case LOOP:
15100 case MAP:
15101 case MAX:
15102 case MEMBER:
15103 case MERGE:
15104 case MIN:
15105 case MINUTE:
15106 case MLSLABEL:
15107 case MODIFY:
15108 case MOD:
15109 case MONTH:
15110 case NATURAL:
15111 case NEW:
15112 case NEW_DOT:
15113 case NO:
15114 case NONEDITIONABLE:
15115 case NOT:
15116 case NULL:
15117 case NULLIF:
15118 case OBJECT:
15119 case OID:
15120 case OPAQUE:
15121 case OPEN:
15122 case OPERATOR:
15123 case ORGANIZATION:
15124 case OTHERS:
15125 case OVERRIDING:
15126 case PACKAGE:
15127 case PARTITION:
15128 case PIPE:
15129 case PRAGMA:
15130 case PRESERVE:
15131 case PRIVATE:
15132 case PROCEDURE:
15133 case RAISE:
15134 case RANGE:
15135 case RAW:
15136 case REAL:
15137 case RECORD:
15138 case REF:
15139 case RELEASE:
15140 case RELIES_ON:
15141 case RENAME:
15142 case RESULT:
15143 case RETURN:
15144 case RETURNING:
15145 case REVERSE:
15146 case ROLLBACK:
15147 case ROW:
15148 case ROWS:
15149 case ROWID:
15150 case ROWNUM:
15151 case SAVE:
15152 case SAVEPOINT:
15153 case SECOND:
15154 case SELECT:
15155 case SELF:
15156 case SET:
15157 case SPACE:
15158 case SQL:
15159 case SQLCODE:
15160 case SQLERRM:
15161 case STATIC:
15162 case SUBTYPE:
15163 case SUBSTITUTABLE:
15164 case SUCCESSFUL:
15165 case SYSDATE:
15166 case SYS_REFCURSOR:
15167 case TEMPORARY:
15168 case TIME:
15169 case TIMESTAMP:
15170 case TIMEZONE_REGION:
15171 case TIMEZONE_ABBR:
15172 case TIMEZONE_MINUTE:
15173 case TIMEZONE_HOUR:
15174 case TRANSACTION:
15175 case TRUE:
15176 case TYPE:
15177 case UNDER:
15178 case USING:
15179 case WHILE:
15180 case YES:
15181 case SHOW:
15182 case A:
15183 case UPDATE:
15184 case DOUBLE:
15185 case DEC:
15186 case PRECISION:
15187 case INT:
15188 case NUMERIC:
15189 case NCHAR:
15190 case NVARCHAR2:
15191 case STRING:
15192 case UROWID:
15193 case VARRAY:
15194 case VARYING:
15195 case BFILE:
15196 case BLOB:
15197 case CLOB:
15198 case NCLOB:
15199 case YEAR:
15200 case LOCAL:
15201 case WITH:
15202 case ZONE:
15203 case CHARACTER:
15204 case AFTER:
15205 case BEFORE:
15206 case OLD:
15207 case PARENT:
15208 case CC_IF:
15209 case CC_ERROR:
15210 case ANALYZE:
15211 case ASSOCIATE:
15212 case AUDIT:
15213 case COMPOUND:
15214 case DATABASE:
15215 case CALL:
15216 case DDL:
15217 case DISASSOCIATE:
15218 case EACH:
15219 case FOLLOWS:
15220 case LOGOFF:
15221 case LOGON:
15222 case NESTED:
15223 case NOAUDIT:
15224 case SCHEMA:
15225 case SERVERERROR:
15226 case SHUTDOWN:
15227 case STARTUP:
15228 case STATEMENT:
15229 case STATISTICS:
15230 case SUSPEND:
15231 case TRUNCATE:
15232 case WRAPPED:
15233 case LIBRARY:
15234 case NAME:
15235 case STRUCT:
15236 case CONTEXT:
15237 case PARAMETERS:
15238 case LENGTH:
15239 case TDO:
15240 case MAXLEN:
15241 case CHARSETID:
15242 case CHARSETFORM:
15243 case ACCEPT:
15244 case ACCESSIBLE:
15245 case COPY:
15246 case DEFINE:
15247 case DISCONNECT:
15248 case HOST:
15249 case PRINT:
15250 case QUIT:
15251 case REMARK:
15252 case UNDEFINE:
15253 case VARIABLE:
15254 case WHENEVER:
15255 case ATTACH:
15256 case CAST:
15257 case TREAT:
15258 case TRIM:
15259 case LEFT:
15260 case RIGHT:
15261 case BOTH:
15262 case EMPTY:
15263 case MULTISET:
15264 case SUBMULTISET:
15265 case LEADING:
15266 case TRAILING:
15267 case CHAR_CS:
15268 case NCHAR_CS:
15269 case DBTIMEZONE:
15270 case SESSIONTIMEZONE:
15271 case AUTHENTICATED:
15272 case LINK:
15273 case SHARED:
15274 case DIRECTORY:
15275 case USER:
15276 case IDENTIFIER:
15277 case UNSIGNED_NUMERIC_LITERAL:
15278 case CHARACTER_LITERAL:
15279 case STRING_LITERAL:
15280 case QUOTED_LITERAL:
15281 ;
15282 break;
15283 default:
15284 jj_la1[178] = jj_gen;
15285 break label_41;
15286 }
15287 }
15288 }
15289 label_42:
15290 while (true) {
15291 switch (jj_nt.kind) {
15292 case CC_ELSE:
15293 ;
15294 break;
15295 default:
15296 jj_la1[179] = jj_gen;
15297 break label_42;
15298 }
15299 jj_consume_token(CC_ELSE);
15300 label_43:
15301 while (true) {
15302 Statement();
15303 switch (jj_nt.kind) {
15304 case 5:
15305 case 16:
15306 case 17:
15307 case 21:
15308 case REPLACE:
15309 case DEFINER:
15310 case CURRENT_USER:
15311 case LANGUAGE:
15312 case INLINE:
15313 case ADD:
15314 case AGGREGATE:
15315 case ARRAY:
15316 case AT:
15317 case ATTRIBUTE:
15318 case AUTHID:
15319 case BEGIN:
15320 case BODY:
15321 case BULK:
15322 case BYTE:
15323 case CASCADE:
15324 case CASE:
15325 case CLOSE:
15326 case COALESCE:
15327 case COLLECT:
15328 case COLUMN:
15329 case COMMENT:
15330 case COMMIT:
15331 case CONSTRUCTOR:
15332 case CONTINUE:
15333 case CONVERT:
15334 case CURRENT:
15335 case CURSOR:
15336 case DATA:
15337 case DATE:
15338 case DAY:
15339 case DECLARE:
15340 case DELETE:
15341 case DISABLE:
15342 case EDITIONABLE:
15343 case ELEMENT:
15344 case ENABLE:
15345 case ESCAPE:
15346 case EXCEPT:
15347 case EXCEPTIONS:
15348 case EXECUTE:
15349 case EXIT:
15350 case EXTERNAL:
15351 case EXTENDS:
15352 case EXTRACT:
15353 case FALSE:
15354 case FETCH:
15355 case FINAL:
15356 case FOR:
15357 case FORALL:
15358 case FORCE:
15359 case FUNCTION:
15360 case GLOBAL:
15361 case GOTO:
15362 case HASH:
15363 case HEAP:
15364 case HOUR:
15365 case IF:
15366 case IMMEDIATE:
15367 case INDICES:
15368 case INDEXTYPE:
15369 case INDICATOR:
15370 case INSERT:
15371 case INSTANTIABLE:
15372 case INTERVAL:
15373 case INVALIDATE:
15374 case ISOLATION:
15375 case JAVA:
15376 case LEVEL:
15377 case LIMIT:
15378 case LOCK:
15379 case LOOP:
15380 case MAP:
15381 case MAX:
15382 case MEMBER:
15383 case MERGE:
15384 case MIN:
15385 case MINUTE:
15386 case MLSLABEL:
15387 case MODIFY:
15388 case MOD:
15389 case MONTH:
15390 case NATURAL:
15391 case NEW:
15392 case NEW_DOT:
15393 case NO:
15394 case NONEDITIONABLE:
15395 case NOT:
15396 case NULL:
15397 case NULLIF:
15398 case OBJECT:
15399 case OID:
15400 case OPAQUE:
15401 case OPEN:
15402 case OPERATOR:
15403 case ORGANIZATION:
15404 case OTHERS:
15405 case OVERRIDING:
15406 case PACKAGE:
15407 case PARTITION:
15408 case PIPE:
15409 case PRAGMA:
15410 case PRESERVE:
15411 case PRIVATE:
15412 case PROCEDURE:
15413 case RAISE:
15414 case RANGE:
15415 case RAW:
15416 case REAL:
15417 case RECORD:
15418 case REF:
15419 case RELEASE:
15420 case RELIES_ON:
15421 case RENAME:
15422 case RESULT:
15423 case RETURN:
15424 case RETURNING:
15425 case REVERSE:
15426 case ROLLBACK:
15427 case ROW:
15428 case ROWS:
15429 case ROWID:
15430 case ROWNUM:
15431 case SAVE:
15432 case SAVEPOINT:
15433 case SECOND:
15434 case SELECT:
15435 case SELF:
15436 case SET:
15437 case SPACE:
15438 case SQL:
15439 case SQLCODE:
15440 case SQLERRM:
15441 case STATIC:
15442 case SUBTYPE:
15443 case SUBSTITUTABLE:
15444 case SUCCESSFUL:
15445 case SYSDATE:
15446 case SYS_REFCURSOR:
15447 case TEMPORARY:
15448 case TIME:
15449 case TIMESTAMP:
15450 case TIMEZONE_REGION:
15451 case TIMEZONE_ABBR:
15452 case TIMEZONE_MINUTE:
15453 case TIMEZONE_HOUR:
15454 case TRANSACTION:
15455 case TRUE:
15456 case TYPE:
15457 case UNDER:
15458 case USING:
15459 case WHILE:
15460 case YES:
15461 case SHOW:
15462 case A:
15463 case UPDATE:
15464 case DOUBLE:
15465 case DEC:
15466 case PRECISION:
15467 case INT:
15468 case NUMERIC:
15469 case NCHAR:
15470 case NVARCHAR2:
15471 case STRING:
15472 case UROWID:
15473 case VARRAY:
15474 case VARYING:
15475 case BFILE:
15476 case BLOB:
15477 case CLOB:
15478 case NCLOB:
15479 case YEAR:
15480 case LOCAL:
15481 case WITH:
15482 case ZONE:
15483 case CHARACTER:
15484 case AFTER:
15485 case BEFORE:
15486 case OLD:
15487 case PARENT:
15488 case CC_IF:
15489 case CC_ERROR:
15490 case ANALYZE:
15491 case ASSOCIATE:
15492 case AUDIT:
15493 case COMPOUND:
15494 case DATABASE:
15495 case CALL:
15496 case DDL:
15497 case DISASSOCIATE:
15498 case EACH:
15499 case FOLLOWS:
15500 case LOGOFF:
15501 case LOGON:
15502 case NESTED:
15503 case NOAUDIT:
15504 case SCHEMA:
15505 case SERVERERROR:
15506 case SHUTDOWN:
15507 case STARTUP:
15508 case STATEMENT:
15509 case STATISTICS:
15510 case SUSPEND:
15511 case TRUNCATE:
15512 case WRAPPED:
15513 case LIBRARY:
15514 case NAME:
15515 case STRUCT:
15516 case CONTEXT:
15517 case PARAMETERS:
15518 case LENGTH:
15519 case TDO:
15520 case MAXLEN:
15521 case CHARSETID:
15522 case CHARSETFORM:
15523 case ACCEPT:
15524 case ACCESSIBLE:
15525 case COPY:
15526 case DEFINE:
15527 case DISCONNECT:
15528 case HOST:
15529 case PRINT:
15530 case QUIT:
15531 case REMARK:
15532 case UNDEFINE:
15533 case VARIABLE:
15534 case WHENEVER:
15535 case ATTACH:
15536 case CAST:
15537 case TREAT:
15538 case TRIM:
15539 case LEFT:
15540 case RIGHT:
15541 case BOTH:
15542 case EMPTY:
15543 case MULTISET:
15544 case SUBMULTISET:
15545 case LEADING:
15546 case TRAILING:
15547 case CHAR_CS:
15548 case NCHAR_CS:
15549 case DBTIMEZONE:
15550 case SESSIONTIMEZONE:
15551 case AUTHENTICATED:
15552 case LINK:
15553 case SHARED:
15554 case DIRECTORY:
15555 case USER:
15556 case IDENTIFIER:
15557 case UNSIGNED_NUMERIC_LITERAL:
15558 case CHARACTER_LITERAL:
15559 case STRING_LITERAL:
15560 case QUOTED_LITERAL:
15561 ;
15562 break;
15563 default:
15564 jj_la1[180] = jj_gen;
15565 break label_43;
15566 }
15567 }
15568 }
15569 jj_consume_token(CC_END);
15570 break;
15571 case CC_ERROR:
15572 jj_consume_token(CC_ERROR);
15573 Expression();
15574 jj_consume_token(CC_END);
15575 break;
15576 default:
15577 jj_la1[181] = jj_gen;
15578 jj_consume_token(-1);
15579 throw new ParseException();
15580 }
15581 jjtree.closeNodeScope(jjtn000, true);
15582 jjtc000 = false;
15583 {if (true) return jjtn000 ;}
15584 } catch (Throwable jjte000) {
15585 if (jjtc000) {
15586 jjtree.clearNodeScope(jjtn000);
15587 jjtc000 = false;
15588 } else {
15589 jjtree.popNode();
15590 }
15591 if (jjte000 instanceof RuntimeException) {
15592 {if (true) throw (RuntimeException)jjte000;}
15593 }
15594 if (jjte000 instanceof ParseException) {
15595 {if (true) throw (ParseException)jjte000;}
15596 }
15597 {if (true) throw (Error)jjte000;}
15598 } finally {
15599 if (jjtc000) {
15600 jjtree.closeNodeScope(jjtn000, true);
15601 }
15602 }
15603 throw new Error("Missing return statement in function");
15604 }
15605
15606 final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15607
15608 ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15609 boolean jjtc000 = true;
15610 jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15611 Token collection = null, collection2 = null;
15612 PLSQLNode name = null;
15613 PLSQLNode startElement = null, endElement = null;
15614 PLSQLNode baseType = null, returnType = null, indexBy = null ;
15615 int lastField = 0;
15616 try {
15617 switch (jj_nt.kind) {
15618 case SUBTYPE:
15619 jj_consume_token(SUBTYPE);
15620 name = QualifiedID();
15621 jj_consume_token(IS);
15622 Datatype();
15623 switch (jj_nt.kind) {
15624 case 5:
15625 case RANGE:
15626 switch (jj_nt.kind) {
15627 case 5:
15628 jj_consume_token(5);
15629 jj_consume_token(IDENTIFIER);
15630 jj_consume_token(7);
15631 break;
15632 case RANGE:
15633 jj_consume_token(RANGE);
15634 UnaryExpression(true);
15635 jj_consume_token(12);
15636 UnaryExpression(true);
15637 break;
15638 default:
15639 jj_la1[182] = jj_gen;
15640 jj_consume_token(-1);
15641 throw new ParseException();
15642 }
15643 break;
15644 default:
15645 jj_la1[183] = jj_gen;
15646 ;
15647 }
15648 switch (jj_nt.kind) {
15649 case NOT:
15650 jj_consume_token(NOT);
15651 jj_consume_token(NULL);
15652 break;
15653 default:
15654 jj_la1[184] = jj_gen;
15655 ;
15656 }
15657 break;
15658 case TYPE:
15659 jj_consume_token(TYPE);
15660 name = QualifiedID();
15661 switch (jj_nt.kind) {
15662 case IS:
15663 jj_consume_token(IS);
15664 break;
15665 case AS:
15666 jj_consume_token(AS);
15667 break;
15668 default:
15669 jj_la1[185] = jj_gen;
15670 jj_consume_token(-1);
15671 throw new ParseException();
15672 }
15673 if (jj_2_44(2)) {
15674 jj_consume_token(NEW);
15675 switch (jj_nt.kind) {
15676 case CHAR_BASE:
15677 jj_consume_token(CHAR_BASE);
15678 break;
15679 case DATE_BASE:
15680 jj_consume_token(DATE_BASE);
15681 break;
15682 case CLOB_BASE:
15683 jj_consume_token(CLOB_BASE);
15684 break;
15685 case BLOB_BASE:
15686 jj_consume_token(BLOB_BASE);
15687 break;
15688 case BFILE_BASE:
15689 jj_consume_token(BFILE_BASE);
15690 break;
15691 case NUMBER_BASE:
15692 jj_consume_token(NUMBER_BASE);
15693 break;
15694 default:
15695 jj_la1[186] = jj_gen;
15696 jj_consume_token(-1);
15697 throw new ParseException();
15698 }
15699 } else {
15700 switch (jj_nt.kind) {
15701 case OBJECT:
15702 jj_consume_token(OBJECT);
15703 jj_consume_token(5);
15704 FieldDeclaration();
15705 label_44:
15706 while (true) {
15707 switch (jj_nt.kind) {
15708 case 6:
15709 ;
15710 break;
15711 default:
15712 jj_la1[187] = jj_gen;
15713 break label_44;
15714 }
15715 jj_consume_token(6);
15716 FieldDeclaration();
15717 }
15718 jj_consume_token(7);
15719 break;
15720 case RECORD:
15721 jj_consume_token(RECORD);
15722 jj_consume_token(5);
15723 FieldDeclaration();
15724 label_45:
15725 while (true) {
15726 switch (jj_nt.kind) {
15727 case 6:
15728 ;
15729 break;
15730 default:
15731 jj_la1[188] = jj_gen;
15732 break label_45;
15733 }
15734 jj_consume_token(6);
15735 FieldDeclaration();
15736 }
15737 jj_consume_token(7);
15738 break;
15739 case TABLE:
15740 case VARRAY:
15741 case VARYING:
15742 switch (jj_nt.kind) {
15743 case TABLE:
15744 jj_consume_token(TABLE);
15745 break;
15746 case VARRAY:
15747 jj_consume_token(VARRAY);
15748 break;
15749 case VARYING:
15750 jj_consume_token(VARYING);
15751 jj_consume_token(ARRAY);
15752 break;
15753 default:
15754 jj_la1[189] = jj_gen;
15755 jj_consume_token(-1);
15756 throw new ParseException();
15757 }
15758 switch (jj_nt.kind) {
15759 case 5:
15760 jj_consume_token(5);
15761 NumericLiteral();
15762 jj_consume_token(7);
15763 break;
15764 default:
15765 jj_la1[190] = jj_gen;
15766 ;
15767 }
15768 jj_consume_token(OF);
15769 Datatype();
15770 switch (jj_nt.kind) {
15771 case NOT:
15772 jj_consume_token(NOT);
15773 jj_consume_token(NULL);
15774 break;
15775 default:
15776 jj_la1[191] = jj_gen;
15777 ;
15778 }
15779 switch (jj_nt.kind) {
15780 case INDEX:
15781 jj_consume_token(INDEX);
15782 jj_consume_token(BY);
15783 Datatype();
15784 break;
15785 default:
15786 jj_la1[192] = jj_gen;
15787 ;
15788 }
15789 break;
15790 case REF:
15791 jj_consume_token(REF);
15792 jj_consume_token(CURSOR);
15793 switch (jj_nt.kind) {
15794 case RETURN:
15795 jj_consume_token(RETURN);
15796 Datatype();
15797 break;
15798 default:
15799 jj_la1[193] = jj_gen;
15800 ;
15801 }
15802 break;
15803 case 5:
15804 jj_consume_token(5);
15805 Expression();
15806 label_46:
15807 while (true) {
15808 switch (jj_nt.kind) {
15809 case 6:
15810 ;
15811 break;
15812 default:
15813 jj_la1[194] = jj_gen;
15814 break label_46;
15815 }
15816 jj_consume_token(6);
15817 Expression();
15818 }
15819 jj_consume_token(7);
15820 break;
15821 case REPLACE:
15822 case DEFINER:
15823 case CURRENT_USER:
15824 case LANGUAGE:
15825 case INLINE:
15826 case ADD:
15827 case AGGREGATE:
15828 case ARRAY:
15829 case AT:
15830 case ATTRIBUTE:
15831 case AUTHID:
15832 case BINARY_INTEGER:
15833 case BODY:
15834 case BOOLEAN:
15835 case BULK:
15836 case BYTE:
15837 case CASCADE:
15838 case CHAR:
15839 case CHAR_BASE:
15840 case CLOSE:
15841 case COALESCE:
15842 case COLLECT:
15843 case COLUMN:
15844 case COMMENT:
15845 case COMMIT:
15846 case CONSTRUCTOR:
15847 case CONTINUE:
15848 case CONVERT:
15849 case CURRENT:
15850 case CURSOR:
15851 case DATA:
15852 case DATE:
15853 case DAY:
15854 case DECIMAL:
15855 case DISABLE:
15856 case EDITIONABLE:
15857 case ELEMENT:
15858 case ENABLE:
15859 case ESCAPE:
15860 case EXCEPT:
15861 case EXCEPTIONS:
15862 case EXIT:
15863 case EXTERNAL:
15864 case EXTENDS:
15865 case EXTRACT:
15866 case FALSE:
15867 case FINAL:
15868 case FLOAT:
15869 case FORCE:
15870 case FUNCTION:
15871 case GLOBAL:
15872 case HASH:
15873 case HEAP:
15874 case HOUR:
15875 case IMMEDIATE:
15876 case INDICES:
15877 case INDEXTYPE:
15878 case INDICATOR:
15879 case INSTANTIABLE:
15880 case INTEGER:
15881 case INTERVAL:
15882 case INVALIDATE:
15883 case ISOLATION:
15884 case JAVA:
15885 case LEVEL:
15886 case LIMIT:
15887 case LONG:
15888 case LOOP:
15889 case MAP:
15890 case MAX:
15891 case MEMBER:
15892 case MERGE:
15893 case MIN:
15894 case MINUTE:
15895 case MLSLABEL:
15896 case MODIFY:
15897 case MOD:
15898 case MONTH:
15899 case NATURAL:
15900 case NATURALN:
15901 case NEW:
15902 case NO:
15903 case NONEDITIONABLE:
15904 case NULLIF:
15905 case NUMBER:
15906 case BFILE_BASE:
15907 case BLOB_BASE:
15908 case CLOB_BASE:
15909 case DATE_BASE:
15910 case NUMBER_BASE:
15911 case OID:
15912 case OPAQUE:
15913 case OPEN:
15914 case OPERATOR:
15915 case ORGANIZATION:
15916 case OTHERS:
15917 case OVERRIDING:
15918 case PACKAGE:
15919 case PARTITION:
15920 case PLS_INTEGER:
15921 case POSITIVE:
15922 case POSITIVEN:
15923 case PRESERVE:
15924 case PRIVATE:
15925 case PROCEDURE:
15926 case RANGE:
15927 case RAW:
15928 case REAL:
15929 case RELEASE:
15930 case RELIES_ON:
15931 case RENAME:
15932 case RESULT:
15933 case RETURN:
15934 case RETURNING:
15935 case REVERSE:
15936 case ROLLBACK:
15937 case ROW:
15938 case ROWS:
15939 case ROWID:
15940 case ROWNUM:
15941 case SAVE:
15942 case SAVEPOINT:
15943 case SECOND:
15944 case SELF:
15945 case SET:
15946 case SMALLINT:
15947 case SPACE:
15948 case SQL:
15949 case SQLCODE:
15950 case SQLERRM:
15951 case STATIC:
15952 case SUBTYPE:
15953 case SUBSTITUTABLE:
15954 case SUCCESSFUL:
15955 case SYSDATE:
15956 case SYS_REFCURSOR:
15957 case TEMPORARY:
15958 case TIME:
15959 case TIMESTAMP:
15960 case TIMEZONE_REGION:
15961 case TIMEZONE_ABBR:
15962 case TIMEZONE_MINUTE:
15963 case TIMEZONE_HOUR:
15964 case TRANSACTION:
15965 case TRUE:
15966 case TYPE:
15967 case UNDER:
15968 case USING:
15969 case YES:
15970 case SHOW:
15971 case A:
15972 case VARCHAR:
15973 case VARCHAR2:
15974 case DOUBLE:
15975 case DEC:
15976 case PRECISION:
15977 case INT:
15978 case NUMERIC:
15979 case SIGNTYPE:
15980 case NCHAR:
15981 case NVARCHAR2:
15982 case STRING:
15983 case UROWID:
15984 case BFILE:
15985 case BLOB:
15986 case CLOB:
15987 case NCLOB:
15988 case YEAR:
15989 case LOCAL:
15990 case ZONE:
15991 case CHARACTER:
15992 case AFTER:
15993 case BEFORE:
15994 case OLD:
15995 case PARENT:
15996 case CC_IF:
15997 case ANALYZE:
15998 case ASSOCIATE:
15999 case AUDIT:
16000 case COMPOUND:
16001 case DATABASE:
16002 case CALL:
16003 case DDL:
16004 case DISASSOCIATE:
16005 case EACH:
16006 case FOLLOWS:
16007 case LOGOFF:
16008 case LOGON:
16009 case NESTED:
16010 case NOAUDIT:
16011 case SCHEMA:
16012 case SERVERERROR:
16013 case SHUTDOWN:
16014 case STARTUP:
16015 case STATEMENT:
16016 case STATISTICS:
16017 case SUSPEND:
16018 case TRUNCATE:
16019 case WRAPPED:
16020 case LIBRARY:
16021 case NAME:
16022 case STRUCT:
16023 case CONTEXT:
16024 case PARAMETERS:
16025 case LENGTH:
16026 case TDO:
16027 case MAXLEN:
16028 case CHARSETID:
16029 case CHARSETFORM:
16030 case ACCEPT:
16031 case ACCESSIBLE:
16032 case COPY:
16033 case DEFINE:
16034 case DISCONNECT:
16035 case HOST:
16036 case PRINT:
16037 case QUIT:
16038 case REMARK:
16039 case UNDEFINE:
16040 case VARIABLE:
16041 case WHENEVER:
16042 case ATTACH:
16043 case CAST:
16044 case TREAT:
16045 case TRIM:
16046 case LEFT:
16047 case RIGHT:
16048 case BOTH:
16049 case EMPTY:
16050 case MULTISET:
16051 case SUBMULTISET:
16052 case LEADING:
16053 case TRAILING:
16054 case CHAR_CS:
16055 case NCHAR_CS:
16056 case DBTIMEZONE:
16057 case SESSIONTIMEZONE:
16058 case AUTHENTICATED:
16059 case LINK:
16060 case SHARED:
16061 case DIRECTORY:
16062 case USER:
16063 case IDENTIFIER:
16064 case QUOTED_LITERAL:
16065 Datatype();
16066 break;
16067 default:
16068 jj_la1[195] = jj_gen;
16069 jj_consume_token(-1);
16070 throw new ParseException();
16071 }
16072 }
16073 break;
16074 default:
16075 jj_la1[196] = jj_gen;
16076 jj_consume_token(-1);
16077 throw new ParseException();
16078 }
16079 jj_consume_token(4);
16080 jjtree.closeNodeScope(jjtn000, true);
16081 jjtc000 = false;
16082 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16083 } catch (Throwable jjte000) {
16084 if (jjtc000) {
16085 jjtree.clearNodeScope(jjtn000);
16086 jjtc000 = false;
16087 } else {
16088 jjtree.popNode();
16089 }
16090 if (jjte000 instanceof RuntimeException) {
16091 {if (true) throw (RuntimeException)jjte000;}
16092 }
16093 if (jjte000 instanceof ParseException) {
16094 {if (true) throw (ParseException)jjte000;}
16095 }
16096 {if (true) throw (Error)jjte000;}
16097 } finally {
16098 if (jjtc000) {
16099 jjtree.closeNodeScope(jjtn000, true);
16100 }
16101 }
16102 throw new Error("Missing return statement in function");
16103 }
16104
16105 final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16106
16107 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16108 boolean jjtc000 = true;
16109 jjtree.openNodeScope(jjtn000);PLSQLNode name;
16110 PLSQLNode dataType;
16111 PLSQLNode defaultValue = null;
16112 try {
16113 name = ID();
16114 Datatype();
16115 switch (jj_nt.kind) {
16116 case NOT:
16117 case NULL:
16118 switch (jj_nt.kind) {
16119 case NOT:
16120 jj_consume_token(NOT);
16121 break;
16122 default:
16123 jj_la1[197] = jj_gen;
16124 ;
16125 }
16126 jj_consume_token(NULL);
16127 break;
16128 default:
16129 jj_la1[198] = jj_gen;
16130 ;
16131 }
16132 switch (jj_nt.kind) {
16133 case 9:
16134 case _DEFAULT:
16135 switch (jj_nt.kind) {
16136 case 9:
16137 jj_consume_token(9);
16138 jj_consume_token(10);
16139 break;
16140 case _DEFAULT:
16141 jj_consume_token(_DEFAULT);
16142 break;
16143 default:
16144 jj_la1[199] = jj_gen;
16145 jj_consume_token(-1);
16146 throw new ParseException();
16147 }
16148 Expression();
16149 break;
16150 default:
16151 jj_la1[200] = jj_gen;
16152 ;
16153 }
16154 jjtree.closeNodeScope(jjtn000, true);
16155 jjtc000 = false;
16156 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16157 } catch (Throwable jjte000) {
16158 if (jjtc000) {
16159 jjtree.clearNodeScope(jjtn000);
16160 jjtc000 = false;
16161 } else {
16162 jjtree.popNode();
16163 }
16164 if (jjte000 instanceof RuntimeException) {
16165 {if (true) throw (RuntimeException)jjte000;}
16166 }
16167 if (jjte000 instanceof ParseException) {
16168 {if (true) throw (ParseException)jjte000;}
16169 }
16170 {if (true) throw (Error)jjte000;}
16171 } finally {
16172 if (jjtc000) {
16173 jjtree.closeNodeScope(jjtn000, true);
16174 }
16175 }
16176 throw new Error("Missing return statement in function");
16177 }
16178
16179 final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16180
16181 ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16182 boolean jjtc000 = true;
16183 jjtree.openNodeScope(jjtn000);Token t = null ;
16184 try {
16185 t = jj_consume_token(IDENTIFIER);
16186 jjtree.closeNodeScope(jjtn000, true);
16187 jjtc000 = false;
16188 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16189 } finally {
16190 if (jjtc000) {
16191 jjtree.closeNodeScope(jjtn000, true);
16192 }
16193 }
16194 throw new Error("Missing return statement in function");
16195 }
16196
16197 final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16198
16199 ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16200 boolean jjtc000 = true;
16201 jjtree.openNodeScope(jjtn000);Token t = null ;
16202 try {
16203 t = jj_consume_token(IDENTIFIER);
16204 jjtree.closeNodeScope(jjtn000, true);
16205 jjtc000 = false;
16206 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16207 } finally {
16208 if (jjtc000) {
16209 jjtree.closeNodeScope(jjtn000, true);
16210 }
16211 }
16212 throw new Error("Missing return statement in function");
16213 }
16214
16215 final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16216
16217 ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16218 boolean jjtc000 = true;
16219 jjtree.openNodeScope(jjtn000);Token t = null ;
16220 try {
16221 t = jj_consume_token(IDENTIFIER);
16222 jjtree.closeNodeScope(jjtn000, true);
16223 jjtc000 = false;
16224 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16225 } finally {
16226 if (jjtc000) {
16227 jjtree.closeNodeScope(jjtn000, true);
16228 }
16229 }
16230 throw new Error("Missing return statement in function");
16231 }
16232
16233
16234 final public ASTCallSpecTail CallSpecTail() throws ParseException {
16235
16236 ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16237 boolean jjtc000 = true;
16238 jjtree.openNodeScope(jjtn000);
16239 try {
16240 switch (jj_nt.kind) {
16241 case EXTERNAL:
16242 jj_consume_token(EXTERNAL);
16243 break;
16244 case LANGUAGE:
16245 jj_consume_token(LANGUAGE);
16246 switch (jj_nt.kind) {
16247 case IDENTIFIER:
16248 jj_consume_token(IDENTIFIER);
16249 break;
16250 case JAVA:
16251 jj_consume_token(JAVA);
16252 break;
16253 default:
16254 jj_la1[201] = jj_gen;
16255 jj_consume_token(-1);
16256 throw new ParseException();
16257 }
16258 break;
16259 default:
16260 jj_la1[202] = jj_gen;
16261 jj_consume_token(-1);
16262 throw new ParseException();
16263 }
16264 label_47:
16265 while (true) {
16266 switch (jj_nt.kind) {
16267 case WITH:
16268 case LIBRARY:
16269 case NAME:
16270 case PARAMETERS:
16271 ;
16272 break;
16273 default:
16274 jj_la1[203] = jj_gen;
16275 break label_47;
16276 }
16277 switch (jj_nt.kind) {
16278 case LIBRARY:
16279 jj_consume_token(LIBRARY);
16280 switch (jj_nt.kind) {
16281 case IDENTIFIER:
16282 jj_consume_token(IDENTIFIER);
16283 break;
16284 case QUOTED_LITERAL:
16285 jj_consume_token(QUOTED_LITERAL);
16286 break;
16287 case STRING_LITERAL:
16288 StringLiteral();
16289 break;
16290 default:
16291 jj_la1[204] = jj_gen;
16292 jj_consume_token(-1);
16293 throw new ParseException();
16294 }
16295 switch (jj_nt.kind) {
16296 case 3:
16297 jj_consume_token(3);
16298 switch (jj_nt.kind) {
16299 case IDENTIFIER:
16300 jj_consume_token(IDENTIFIER);
16301 break;
16302 case QUOTED_LITERAL:
16303 jj_consume_token(QUOTED_LITERAL);
16304 break;
16305 case STRING_LITERAL:
16306 StringLiteral();
16307 break;
16308 default:
16309 jj_la1[205] = jj_gen;
16310 jj_consume_token(-1);
16311 throw new ParseException();
16312 }
16313 break;
16314 default:
16315 jj_la1[206] = jj_gen;
16316 ;
16317 }
16318 break;
16319 case NAME:
16320 jj_consume_token(NAME);
16321 switch (jj_nt.kind) {
16322 case IDENTIFIER:
16323 jj_consume_token(IDENTIFIER);
16324 break;
16325 case QUOTED_LITERAL:
16326 jj_consume_token(QUOTED_LITERAL);
16327 break;
16328 case STRING_LITERAL:
16329 StringLiteral();
16330 break;
16331 default:
16332 jj_la1[207] = jj_gen;
16333 jj_consume_token(-1);
16334 throw new ParseException();
16335 }
16336 break;
16337 case WITH:
16338 jj_consume_token(WITH);
16339 jj_consume_token(CONTEXT);
16340 break;
16341 case PARAMETERS:
16342 jj_consume_token(PARAMETERS);
16343 SkipPastNextOccurrence(")");
16344 break;
16345 default:
16346 jj_la1[208] = jj_gen;
16347 jj_consume_token(-1);
16348 throw new ParseException();
16349 }
16350 }
16351 jjtree.closeNodeScope(jjtn000, true);
16352 jjtc000 = false;
16353 {if (true) return jjtn000 ;}
16354 } catch (Throwable jjte000) {
16355 if (jjtc000) {
16356 jjtree.clearNodeScope(jjtn000);
16357 jjtc000 = false;
16358 } else {
16359 jjtree.popNode();
16360 }
16361 if (jjte000 instanceof RuntimeException) {
16362 {if (true) throw (RuntimeException)jjte000;}
16363 }
16364 if (jjte000 instanceof ParseException) {
16365 {if (true) throw (ParseException)jjte000;}
16366 }
16367 {if (true) throw (Error)jjte000;}
16368 } finally {
16369 if (jjtc000) {
16370 jjtree.closeNodeScope(jjtn000, true);
16371 }
16372 }
16373 throw new Error("Missing return statement in function");
16374 }
16375
16376
16377 final public ASTCursorUnit CursorUnit() throws ParseException {
16378
16379 ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16380 boolean jjtc000 = true;
16381 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16382 try {
16383 jj_consume_token(CURSOR);
16384 simpleNode = ID();
16385 switch (jj_nt.kind) {
16386 case 5:
16387 FormalParameters();
16388 break;
16389 default:
16390 jj_la1[209] = jj_gen;
16391 ;
16392 }
16393 switch (jj_nt.kind) {
16394 case RETURN:
16395 jj_consume_token(RETURN);
16396 Datatype();
16397 break;
16398 default:
16399 jj_la1[210] = jj_gen;
16400 ;
16401 }
16402 switch (jj_nt.kind) {
16403 case IS:
16404 jj_consume_token(IS);
16405 label_48:
16406 while (true) {
16407 switch (jj_nt.kind) {
16408 case 5:
16409 ;
16410 break;
16411 default:
16412 jj_la1[211] = jj_gen;
16413 break label_48;
16414 }
16415 jj_consume_token(5);
16416 }
16417 SqlStatement(null,";");
16418 break;
16419 default:
16420 jj_la1[212] = jj_gen;
16421 ;
16422 }
16423 jj_consume_token(4);
16424 jjtree.closeNodeScope(jjtn000, true);
16425 jjtc000 = false;
16426 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
16427 } catch (Throwable jjte000) {
16428 if (jjtc000) {
16429 jjtree.clearNodeScope(jjtn000);
16430 jjtc000 = false;
16431 } else {
16432 jjtree.popNode();
16433 }
16434 if (jjte000 instanceof RuntimeException) {
16435 {if (true) throw (RuntimeException)jjte000;}
16436 }
16437 if (jjte000 instanceof ParseException) {
16438 {if (true) throw (ParseException)jjte000;}
16439 }
16440 {if (true) throw (Error)jjte000;}
16441 } finally {
16442 if (jjtc000) {
16443 jjtree.closeNodeScope(jjtn000, true);
16444 }
16445 }
16446 throw new Error("Missing return statement in function");
16447 }
16448
16449 final public ASTCursorSpecification CursorSpecification() throws ParseException {
16450
16451 ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16452 boolean jjtc000 = true;
16453 jjtree.openNodeScope(jjtn000);
16454 try {
16455 CursorUnit();
16456 jjtree.closeNodeScope(jjtn000, true);
16457 jjtc000 = false;
16458 {if (true) return jjtn000 ;}
16459 } catch (Throwable jjte000) {
16460 if (jjtc000) {
16461 jjtree.clearNodeScope(jjtn000);
16462 jjtc000 = false;
16463 } else {
16464 jjtree.popNode();
16465 }
16466 if (jjte000 instanceof RuntimeException) {
16467 {if (true) throw (RuntimeException)jjte000;}
16468 }
16469 if (jjte000 instanceof ParseException) {
16470 {if (true) throw (ParseException)jjte000;}
16471 }
16472 {if (true) throw (Error)jjte000;}
16473 } finally {
16474 if (jjtc000) {
16475 jjtree.closeNodeScope(jjtn000, true);
16476 }
16477 }
16478 throw new Error("Missing return statement in function");
16479 }
16480
16481 final public ASTCursorBody CursorBody() throws ParseException {
16482
16483 ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16484 boolean jjtc000 = true;
16485 jjtree.openNodeScope(jjtn000);
16486 try {
16487 CursorUnit();
16488 jjtree.closeNodeScope(jjtn000, true);
16489 jjtc000 = false;
16490 {if (true) return jjtn000 ;}
16491 } catch (Throwable jjte000) {
16492 if (jjtc000) {
16493 jjtree.clearNodeScope(jjtn000);
16494 jjtc000 = false;
16495 } else {
16496 jjtree.popNode();
16497 }
16498 if (jjte000 instanceof RuntimeException) {
16499 {if (true) throw (RuntimeException)jjte000;}
16500 }
16501 if (jjte000 instanceof ParseException) {
16502 {if (true) throw (ParseException)jjte000;}
16503 }
16504 {if (true) throw (Error)jjte000;}
16505 } finally {
16506 if (jjtc000) {
16507 jjtree.closeNodeScope(jjtn000, true);
16508 }
16509 }
16510 throw new Error("Missing return statement in function");
16511 }
16512
16513
16514
16515
16516
16517
16518
16519
16520
16521
16522
16523
16524
16525 final public ASTExpression Expression() throws ParseException {
16526
16527 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16528 boolean jjtc000 = true;
16529 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16530 StringBuilder sb = new StringBuilder() ;
16531 try {
16532 if (jj_2_45(2147483647)) {
16533 simpleNode = Assignment();
16534 sb.append(simpleNode.getImage());
16535 } else {
16536 switch (jj_nt.kind) {
16537 case 5:
16538 case 16:
16539 case 17:
16540 case REPLACE:
16541 case DEFINER:
16542 case CURRENT_USER:
16543 case LANGUAGE:
16544 case INLINE:
16545 case ADD:
16546 case AGGREGATE:
16547 case ARRAY:
16548 case AT:
16549 case ATTRIBUTE:
16550 case AUTHID:
16551 case BODY:
16552 case BULK:
16553 case BYTE:
16554 case CASCADE:
16555 case CASE:
16556 case CLOSE:
16557 case COALESCE:
16558 case COLLECT:
16559 case COLUMN:
16560 case COMMENT:
16561 case COMMIT:
16562 case CONSTRUCTOR:
16563 case CONTINUE:
16564 case CONVERT:
16565 case CURRENT:
16566 case CURSOR:
16567 case DATA:
16568 case DATE:
16569 case DAY:
16570 case DISABLE:
16571 case EDITIONABLE:
16572 case ELEMENT:
16573 case ENABLE:
16574 case ESCAPE:
16575 case EXCEPT:
16576 case EXCEPTIONS:
16577 case EXIT:
16578 case EXTERNAL:
16579 case EXTENDS:
16580 case EXTRACT:
16581 case FALSE:
16582 case FINAL:
16583 case FORCE:
16584 case FUNCTION:
16585 case GLOBAL:
16586 case HASH:
16587 case HEAP:
16588 case HOUR:
16589 case IMMEDIATE:
16590 case INDICES:
16591 case INDEXTYPE:
16592 case INDICATOR:
16593 case INSTANTIABLE:
16594 case INTERVAL:
16595 case INVALIDATE:
16596 case ISOLATION:
16597 case JAVA:
16598 case LEVEL:
16599 case LIMIT:
16600 case LOOP:
16601 case MAP:
16602 case MAX:
16603 case MEMBER:
16604 case MERGE:
16605 case MIN:
16606 case MINUTE:
16607 case MLSLABEL:
16608 case MODIFY:
16609 case MOD:
16610 case MONTH:
16611 case NATURAL:
16612 case NEW:
16613 case NEW_DOT:
16614 case NO:
16615 case NONEDITIONABLE:
16616 case NOT:
16617 case NULL:
16618 case NULLIF:
16619 case OBJECT:
16620 case OID:
16621 case OPAQUE:
16622 case OPEN:
16623 case OPERATOR:
16624 case ORGANIZATION:
16625 case OTHERS:
16626 case OVERRIDING:
16627 case PACKAGE:
16628 case PARTITION:
16629 case PRESERVE:
16630 case PRIVATE:
16631 case PROCEDURE:
16632 case RANGE:
16633 case RAW:
16634 case REAL:
16635 case RECORD:
16636 case REF:
16637 case RELEASE:
16638 case RELIES_ON:
16639 case RENAME:
16640 case RESULT:
16641 case RETURN:
16642 case RETURNING:
16643 case REVERSE:
16644 case ROLLBACK:
16645 case ROW:
16646 case ROWS:
16647 case ROWID:
16648 case ROWNUM:
16649 case SAVE:
16650 case SAVEPOINT:
16651 case SECOND:
16652 case SELECT:
16653 case SELF:
16654 case SET:
16655 case SPACE:
16656 case SQL:
16657 case SQLCODE:
16658 case SQLERRM:
16659 case STATIC:
16660 case SUBTYPE:
16661 case SUBSTITUTABLE:
16662 case SUCCESSFUL:
16663 case SYSDATE:
16664 case SYS_REFCURSOR:
16665 case TEMPORARY:
16666 case TIME:
16667 case TIMESTAMP:
16668 case TIMEZONE_REGION:
16669 case TIMEZONE_ABBR:
16670 case TIMEZONE_MINUTE:
16671 case TIMEZONE_HOUR:
16672 case TRANSACTION:
16673 case TRUE:
16674 case TYPE:
16675 case UNDER:
16676 case USING:
16677 case YES:
16678 case SHOW:
16679 case A:
16680 case DOUBLE:
16681 case DEC:
16682 case PRECISION:
16683 case INT:
16684 case NUMERIC:
16685 case NCHAR:
16686 case NVARCHAR2:
16687 case STRING:
16688 case UROWID:
16689 case VARRAY:
16690 case VARYING:
16691 case BFILE:
16692 case BLOB:
16693 case CLOB:
16694 case NCLOB:
16695 case YEAR:
16696 case LOCAL:
16697 case WITH:
16698 case ZONE:
16699 case CHARACTER:
16700 case AFTER:
16701 case BEFORE:
16702 case OLD:
16703 case PARENT:
16704 case ANALYZE:
16705 case ASSOCIATE:
16706 case AUDIT:
16707 case COMPOUND:
16708 case DATABASE:
16709 case CALL:
16710 case DDL:
16711 case DISASSOCIATE:
16712 case EACH:
16713 case FOLLOWS:
16714 case LOGOFF:
16715 case LOGON:
16716 case NESTED:
16717 case NOAUDIT:
16718 case SCHEMA:
16719 case SERVERERROR:
16720 case SHUTDOWN:
16721 case STARTUP:
16722 case STATEMENT:
16723 case STATISTICS:
16724 case SUSPEND:
16725 case TRUNCATE:
16726 case WRAPPED:
16727 case LIBRARY:
16728 case NAME:
16729 case STRUCT:
16730 case CONTEXT:
16731 case PARAMETERS:
16732 case LENGTH:
16733 case TDO:
16734 case MAXLEN:
16735 case CHARSETID:
16736 case CHARSETFORM:
16737 case ACCEPT:
16738 case ACCESSIBLE:
16739 case COPY:
16740 case DEFINE:
16741 case DISCONNECT:
16742 case HOST:
16743 case PRINT:
16744 case QUIT:
16745 case REMARK:
16746 case UNDEFINE:
16747 case VARIABLE:
16748 case WHENEVER:
16749 case ATTACH:
16750 case CAST:
16751 case TREAT:
16752 case TRIM:
16753 case LEFT:
16754 case RIGHT:
16755 case BOTH:
16756 case EMPTY:
16757 case MULTISET:
16758 case SUBMULTISET:
16759 case LEADING:
16760 case TRAILING:
16761 case CHAR_CS:
16762 case NCHAR_CS:
16763 case DBTIMEZONE:
16764 case SESSIONTIMEZONE:
16765 case AUTHENTICATED:
16766 case LINK:
16767 case SHARED:
16768 case DIRECTORY:
16769 case USER:
16770 case IDENTIFIER:
16771 case UNSIGNED_NUMERIC_LITERAL:
16772 case CHARACTER_LITERAL:
16773 case STRING_LITERAL:
16774 case QUOTED_LITERAL:
16775 simpleNode = ConditionalOrExpression();
16776 sb.append(simpleNode.getImage());
16777 break;
16778 case CC_IF:
16779 simpleNode = CompilationExpression();
16780 sb.append(simpleNode.getImage());
16781 break;
16782 default:
16783 jj_la1[213] = jj_gen;
16784 jj_consume_token(-1);
16785 throw new ParseException();
16786 }
16787 }
16788 jjtree.closeNodeScope(jjtn000, true);
16789 jjtc000 = false;
16790 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16791 } catch (Throwable jjte000) {
16792 if (jjtc000) {
16793 jjtree.clearNodeScope(jjtn000);
16794 jjtc000 = false;
16795 } else {
16796 jjtree.popNode();
16797 }
16798 if (jjte000 instanceof RuntimeException) {
16799 {if (true) throw (RuntimeException)jjte000;}
16800 }
16801 if (jjte000 instanceof ParseException) {
16802 {if (true) throw (ParseException)jjte000;}
16803 }
16804 {if (true) throw (Error)jjte000;}
16805 } finally {
16806 if (jjtc000) {
16807 jjtree.closeNodeScope(jjtn000, true);
16808 }
16809 }
16810 throw new Error("Missing return statement in function");
16811 }
16812
16813 final public ASTCompilationExpression CompilationExpression() throws ParseException {
16814
16815 ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16816 boolean jjtc000 = true;
16817 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16818 StringBuilder sb = new StringBuilder() ;
16819 try {
16820 jj_consume_token(CC_IF);
16821 sb.append(" "); sb.append(token.image) ;
16822 simpleNode = ConditionalOrExpression();
16823 sb.append(" "); sb.append(simpleNode.getImage());
16824 jj_consume_token(CC_THEN);
16825 sb.append(" "); sb.append(token.image);
16826 simpleNode = Expression();
16827 sb.append(" "); sb.append(simpleNode.getImage());
16828 label_49:
16829 while (true) {
16830 switch (jj_nt.kind) {
16831 case CC_ELSIF:
16832 ;
16833 break;
16834 default:
16835 jj_la1[214] = jj_gen;
16836 break label_49;
16837 }
16838 jj_consume_token(CC_ELSIF);
16839 sb.append(" "); sb.append(token.image);
16840 simpleNode = ConditionalOrExpression();
16841 sb.append(" "); sb.append(simpleNode.getImage());
16842 jj_consume_token(CC_THEN);
16843 sb.append(" "); sb.append(token.image);
16844 simpleNode = Expression();
16845 sb.append(" "); sb.append(simpleNode.getImage());
16846 }
16847 label_50:
16848 while (true) {
16849 switch (jj_nt.kind) {
16850 case CC_ELSE:
16851 ;
16852 break;
16853 default:
16854 jj_la1[215] = jj_gen;
16855 break label_50;
16856 }
16857 jj_consume_token(CC_ELSE);
16858 sb.append(" "); sb.append(token.image);
16859 simpleNode = Expression();
16860 sb.append(" "); sb.append(simpleNode.getImage());
16861 }
16862 jj_consume_token(CC_END);
16863 sb.append(" "); sb.append(token.image);
16864 jjtree.closeNodeScope(jjtn000, true);
16865 jjtc000 = false;
16866 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16867 } catch (Throwable jjte000) {
16868 if (jjtc000) {
16869 jjtree.clearNodeScope(jjtn000);
16870 jjtc000 = false;
16871 } else {
16872 jjtree.popNode();
16873 }
16874 if (jjte000 instanceof RuntimeException) {
16875 {if (true) throw (RuntimeException)jjte000;}
16876 }
16877 if (jjte000 instanceof ParseException) {
16878 {if (true) throw (ParseException)jjte000;}
16879 }
16880 {if (true) throw (Error)jjte000;}
16881 } finally {
16882 if (jjtc000) {
16883 jjtree.closeNodeScope(jjtn000, true);
16884 }
16885 }
16886 throw new Error("Missing return statement in function");
16887 }
16888
16889 final public ASTAssignment Assignment() throws ParseException {
16890
16891 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16892 boolean jjtc000 = true;
16893 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16894 try {
16895 simpleNode = PrimaryExpression();
16896 sb.append(simpleNode.getImage());
16897 jj_consume_token(9);
16898 jj_consume_token(10);
16899 sb.append(" := ");
16900 simpleNode = Expression();
16901 sb.append(simpleNode.getImage());
16902 jjtree.closeNodeScope(jjtn000, true);
16903 jjtc000 = false;
16904 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16905 } catch (Throwable jjte000) {
16906 if (jjtc000) {
16907 jjtree.clearNodeScope(jjtn000);
16908 jjtc000 = false;
16909 } else {
16910 jjtree.popNode();
16911 }
16912 if (jjte000 instanceof RuntimeException) {
16913 {if (true) throw (RuntimeException)jjte000;}
16914 }
16915 if (jjte000 instanceof ParseException) {
16916 {if (true) throw (ParseException)jjte000;}
16917 }
16918 {if (true) throw (Error)jjte000;}
16919 } finally {
16920 if (jjtc000) {
16921 jjtree.closeNodeScope(jjtn000, true);
16922 }
16923 }
16924 throw new Error("Missing return statement in function");
16925 }
16926
16927 final public ASTCaseExpression CaseExpression() throws ParseException {
16928
16929 ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16930 boolean jjtc000 = true;
16931 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16932 try {
16933 thisToken = jj_consume_token(CASE);
16934 sb.append(thisToken.image);
16935 switch (jj_nt.kind) {
16936 case 5:
16937 case 16:
16938 case 17:
16939 case REPLACE:
16940 case DEFINER:
16941 case CURRENT_USER:
16942 case LANGUAGE:
16943 case INLINE:
16944 case ADD:
16945 case AGGREGATE:
16946 case ARRAY:
16947 case AT:
16948 case ATTRIBUTE:
16949 case AUTHID:
16950 case BODY:
16951 case BULK:
16952 case BYTE:
16953 case CASCADE:
16954 case CASE:
16955 case CLOSE:
16956 case COALESCE:
16957 case COLLECT:
16958 case COLUMN:
16959 case COMMENT:
16960 case COMMIT:
16961 case CONSTRUCTOR:
16962 case CONTINUE:
16963 case CONVERT:
16964 case CURRENT:
16965 case CURSOR:
16966 case DATA:
16967 case DATE:
16968 case DAY:
16969 case DISABLE:
16970 case EDITIONABLE:
16971 case ELEMENT:
16972 case ENABLE:
16973 case ESCAPE:
16974 case EXCEPT:
16975 case EXCEPTIONS:
16976 case EXIT:
16977 case EXTERNAL:
16978 case EXTENDS:
16979 case EXTRACT:
16980 case FALSE:
16981 case FINAL:
16982 case FORCE:
16983 case FUNCTION:
16984 case GLOBAL:
16985 case HASH:
16986 case HEAP:
16987 case HOUR:
16988 case IMMEDIATE:
16989 case INDICES:
16990 case INDEXTYPE:
16991 case INDICATOR:
16992 case INSTANTIABLE:
16993 case INTERVAL:
16994 case INVALIDATE:
16995 case ISOLATION:
16996 case JAVA:
16997 case LEVEL:
16998 case LIMIT:
16999 case LOOP:
17000 case MAP:
17001 case MAX:
17002 case MEMBER:
17003 case MERGE:
17004 case MIN:
17005 case MINUTE:
17006 case MLSLABEL:
17007 case MODIFY:
17008 case MOD:
17009 case MONTH:
17010 case NATURAL:
17011 case NEW:
17012 case NEW_DOT:
17013 case NO:
17014 case NONEDITIONABLE:
17015 case NOT:
17016 case NULL:
17017 case NULLIF:
17018 case OBJECT:
17019 case OID:
17020 case OPAQUE:
17021 case OPEN:
17022 case OPERATOR:
17023 case ORGANIZATION:
17024 case OTHERS:
17025 case OVERRIDING:
17026 case PACKAGE:
17027 case PARTITION:
17028 case PRESERVE:
17029 case PRIVATE:
17030 case PROCEDURE:
17031 case RANGE:
17032 case RAW:
17033 case REAL:
17034 case RECORD:
17035 case REF:
17036 case RELEASE:
17037 case RELIES_ON:
17038 case RENAME:
17039 case RESULT:
17040 case RETURN:
17041 case RETURNING:
17042 case REVERSE:
17043 case ROLLBACK:
17044 case ROW:
17045 case ROWS:
17046 case ROWID:
17047 case ROWNUM:
17048 case SAVE:
17049 case SAVEPOINT:
17050 case SECOND:
17051 case SELECT:
17052 case SELF:
17053 case SET:
17054 case SPACE:
17055 case SQL:
17056 case SQLCODE:
17057 case SQLERRM:
17058 case STATIC:
17059 case SUBTYPE:
17060 case SUBSTITUTABLE:
17061 case SUCCESSFUL:
17062 case SYSDATE:
17063 case SYS_REFCURSOR:
17064 case TEMPORARY:
17065 case TIME:
17066 case TIMESTAMP:
17067 case TIMEZONE_REGION:
17068 case TIMEZONE_ABBR:
17069 case TIMEZONE_MINUTE:
17070 case TIMEZONE_HOUR:
17071 case TRANSACTION:
17072 case TRUE:
17073 case TYPE:
17074 case UNDER:
17075 case USING:
17076 case YES:
17077 case SHOW:
17078 case A:
17079 case DOUBLE:
17080 case DEC:
17081 case PRECISION:
17082 case INT:
17083 case NUMERIC:
17084 case NCHAR:
17085 case NVARCHAR2:
17086 case STRING:
17087 case UROWID:
17088 case VARRAY:
17089 case VARYING:
17090 case BFILE:
17091 case BLOB:
17092 case CLOB:
17093 case NCLOB:
17094 case YEAR:
17095 case LOCAL:
17096 case WITH:
17097 case ZONE:
17098 case CHARACTER:
17099 case AFTER:
17100 case BEFORE:
17101 case OLD:
17102 case PARENT:
17103 case CC_IF:
17104 case ANALYZE:
17105 case ASSOCIATE:
17106 case AUDIT:
17107 case COMPOUND:
17108 case DATABASE:
17109 case CALL:
17110 case DDL:
17111 case DISASSOCIATE:
17112 case EACH:
17113 case FOLLOWS:
17114 case LOGOFF:
17115 case LOGON:
17116 case NESTED:
17117 case NOAUDIT:
17118 case SCHEMA:
17119 case SERVERERROR:
17120 case SHUTDOWN:
17121 case STARTUP:
17122 case STATEMENT:
17123 case STATISTICS:
17124 case SUSPEND:
17125 case TRUNCATE:
17126 case WRAPPED:
17127 case LIBRARY:
17128 case NAME:
17129 case STRUCT:
17130 case CONTEXT:
17131 case PARAMETERS:
17132 case LENGTH:
17133 case TDO:
17134 case MAXLEN:
17135 case CHARSETID:
17136 case CHARSETFORM:
17137 case ACCEPT:
17138 case ACCESSIBLE:
17139 case COPY:
17140 case DEFINE:
17141 case DISCONNECT:
17142 case HOST:
17143 case PRINT:
17144 case QUIT:
17145 case REMARK:
17146 case UNDEFINE:
17147 case VARIABLE:
17148 case WHENEVER:
17149 case ATTACH:
17150 case CAST:
17151 case TREAT:
17152 case TRIM:
17153 case LEFT:
17154 case RIGHT:
17155 case BOTH:
17156 case EMPTY:
17157 case MULTISET:
17158 case SUBMULTISET:
17159 case LEADING:
17160 case TRAILING:
17161 case CHAR_CS:
17162 case NCHAR_CS:
17163 case DBTIMEZONE:
17164 case SESSIONTIMEZONE:
17165 case AUTHENTICATED:
17166 case LINK:
17167 case SHARED:
17168 case DIRECTORY:
17169 case USER:
17170 case IDENTIFIER:
17171 case UNSIGNED_NUMERIC_LITERAL:
17172 case CHARACTER_LITERAL:
17173 case STRING_LITERAL:
17174 case QUOTED_LITERAL:
17175 simpleNode = Expression();
17176 sb.append(" "); sb.append(simpleNode.getImage());
17177 break;
17178 default:
17179 jj_la1[216] = jj_gen;
17180 ;
17181 }
17182 label_51:
17183 while (true) {
17184 thisToken = jj_consume_token(WHEN);
17185 sb.append(" "); sb.append(thisToken.image);
17186 simpleNode = Expression();
17187 sb.append(" "); sb.append(simpleNode.getImage());
17188 thisToken = jj_consume_token(THEN);
17189 sb.append(" "); sb.append(thisToken.image);
17190 Expression();
17191 sb.append(" "); sb.append(simpleNode.getImage());
17192 switch (jj_nt.kind) {
17193 case WHEN:
17194 ;
17195 break;
17196 default:
17197 jj_la1[217] = jj_gen;
17198 break label_51;
17199 }
17200 }
17201 switch (jj_nt.kind) {
17202 case ELSE:
17203 thisToken = jj_consume_token(ELSE);
17204 sb.append(" "); sb.append(thisToken.image);
17205 Expression();
17206 sb.append(" "); sb.append(simpleNode.getImage());
17207 break;
17208 default:
17209 jj_la1[218] = jj_gen;
17210 ;
17211 }
17212 thisToken = jj_consume_token(END);
17213 sb.append(" "); sb.append(thisToken.image);
17214 jjtree.closeNodeScope(jjtn000, true);
17215 jjtc000 = false;
17216 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17217 } catch (Throwable jjte000) {
17218 if (jjtc000) {
17219 jjtree.clearNodeScope(jjtn000);
17220 jjtc000 = false;
17221 } else {
17222 jjtree.popNode();
17223 }
17224 if (jjte000 instanceof RuntimeException) {
17225 {if (true) throw (RuntimeException)jjte000;}
17226 }
17227 if (jjte000 instanceof ParseException) {
17228 {if (true) throw (ParseException)jjte000;}
17229 }
17230 {if (true) throw (Error)jjte000;}
17231 } finally {
17232 if (jjtc000) {
17233 jjtree.closeNodeScope(jjtn000, true);
17234 }
17235 }
17236 throw new Error("Missing return statement in function");
17237 }
17238
17239
17240
17241
17242 final public ASTLikeExpression LikeExpression() throws ParseException {
17243
17244 ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17245 boolean jjtc000 = true;
17246 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17247 try {
17248 simpleNode = PrimaryExpression();
17249 sb.append(" "); sb.append(simpleNode.getImage());
17250 thisToken = jj_consume_token(LIKE);
17251 sb.append(thisToken.image);
17252 simpleNode = StringExpression();
17253 sb.append(" "); sb.append(simpleNode.getImage());
17254 switch (jj_nt.kind) {
17255 case ESCAPE:
17256 jj_consume_token(ESCAPE);
17257 sb.append(" ESCAPE ");
17258 switch (jj_nt.kind) {
17259 case CHARACTER_LITERAL:
17260 jj_consume_token(CHARACTER_LITERAL);
17261 sb.append(" "); sb.append(token.toString());
17262 break;
17263 case STRING_LITERAL:
17264 simpleNode = StringLiteral();
17265 sb.append(" "); sb.append(simpleNode.getImage());
17266 break;
17267 default:
17268 jj_la1[219] = jj_gen;
17269 jj_consume_token(-1);
17270 throw new ParseException();
17271 }
17272 break;
17273 default:
17274 jj_la1[220] = jj_gen;
17275 ;
17276 }
17277 label_52:
17278 while (true) {
17279 switch (jj_nt.kind) {
17280 case 3:
17281 ;
17282 break;
17283 default:
17284 jj_la1[221] = jj_gen;
17285 break label_52;
17286 }
17287 jj_consume_token(3);
17288 simpleNode = Expression();
17289 sb.append("."); sb.append(simpleNode.getImage());
17290 }
17291 jjtree.closeNodeScope(jjtn000, true);
17292 jjtc000 = false;
17293 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17294 } catch (Throwable jjte000) {
17295 if (jjtc000) {
17296 jjtree.clearNodeScope(jjtn000);
17297 jjtc000 = false;
17298 } else {
17299 jjtree.popNode();
17300 }
17301 if (jjte000 instanceof RuntimeException) {
17302 {if (true) throw (RuntimeException)jjte000;}
17303 }
17304 if (jjte000 instanceof ParseException) {
17305 {if (true) throw (ParseException)jjte000;}
17306 }
17307 {if (true) throw (Error)jjte000;}
17308 } finally {
17309 if (jjtc000) {
17310 jjtree.closeNodeScope(jjtn000, true);
17311 }
17312 }
17313 throw new Error("Missing return statement in function");
17314 }
17315
17316 final public ASTTrimExpression TrimExpression() throws ParseException {
17317
17318 ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17319 boolean jjtc000 = true;
17320 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17321 try {
17322 thisToken = jj_consume_token(TRIM);
17323 sb.append(thisToken.image);
17324 jj_consume_token(5);
17325 sb.append("(");
17326 switch (jj_nt.kind) {
17327 case BOTH:
17328 case LEADING:
17329 case TRAILING:
17330 switch (jj_nt.kind) {
17331 case LEADING:
17332 jj_consume_token(LEADING);
17333 break;
17334 case TRAILING:
17335 jj_consume_token(TRAILING);
17336 break;
17337 case BOTH:
17338 jj_consume_token(BOTH);
17339 break;
17340 default:
17341 jj_la1[222] = jj_gen;
17342 jj_consume_token(-1);
17343 throw new ParseException();
17344 }
17345 sb.append(" "); sb.append(token.toString());
17346 break;
17347 default:
17348 jj_la1[223] = jj_gen;
17349 ;
17350 }
17351 switch (jj_nt.kind) {
17352 case 5:
17353 case REPLACE:
17354 case DEFINER:
17355 case CURRENT_USER:
17356 case LANGUAGE:
17357 case INLINE:
17358 case ADD:
17359 case AGGREGATE:
17360 case ARRAY:
17361 case AT:
17362 case ATTRIBUTE:
17363 case AUTHID:
17364 case BODY:
17365 case BULK:
17366 case BYTE:
17367 case CASCADE:
17368 case CASE:
17369 case CLOSE:
17370 case COALESCE:
17371 case COLLECT:
17372 case COLUMN:
17373 case COMMENT:
17374 case COMMIT:
17375 case CONSTRUCTOR:
17376 case CONTINUE:
17377 case CONVERT:
17378 case CURRENT:
17379 case CURSOR:
17380 case DATA:
17381 case DATE:
17382 case DAY:
17383 case DISABLE:
17384 case EDITIONABLE:
17385 case ELEMENT:
17386 case ENABLE:
17387 case ESCAPE:
17388 case EXCEPT:
17389 case EXCEPTIONS:
17390 case EXIT:
17391 case EXTERNAL:
17392 case EXTENDS:
17393 case EXTRACT:
17394 case FALSE:
17395 case FINAL:
17396 case FORCE:
17397 case FUNCTION:
17398 case GLOBAL:
17399 case HASH:
17400 case HEAP:
17401 case HOUR:
17402 case IMMEDIATE:
17403 case INDICES:
17404 case INDEXTYPE:
17405 case INDICATOR:
17406 case INSTANTIABLE:
17407 case INTERVAL:
17408 case INVALIDATE:
17409 case ISOLATION:
17410 case JAVA:
17411 case LEVEL:
17412 case LIMIT:
17413 case LOOP:
17414 case MAP:
17415 case MAX:
17416 case MEMBER:
17417 case MERGE:
17418 case MIN:
17419 case MINUTE:
17420 case MLSLABEL:
17421 case MODIFY:
17422 case MOD:
17423 case MONTH:
17424 case NATURAL:
17425 case NEW:
17426 case NEW_DOT:
17427 case NO:
17428 case NONEDITIONABLE:
17429 case NULL:
17430 case NULLIF:
17431 case OBJECT:
17432 case OID:
17433 case OPAQUE:
17434 case OPEN:
17435 case OPERATOR:
17436 case ORGANIZATION:
17437 case OTHERS:
17438 case OVERRIDING:
17439 case PACKAGE:
17440 case PARTITION:
17441 case PRESERVE:
17442 case PRIVATE:
17443 case PROCEDURE:
17444 case RANGE:
17445 case RAW:
17446 case REAL:
17447 case RECORD:
17448 case REF:
17449 case RELEASE:
17450 case RELIES_ON:
17451 case RENAME:
17452 case RESULT:
17453 case RETURN:
17454 case RETURNING:
17455 case REVERSE:
17456 case ROLLBACK:
17457 case ROW:
17458 case ROWS:
17459 case ROWID:
17460 case ROWNUM:
17461 case SAVE:
17462 case SAVEPOINT:
17463 case SECOND:
17464 case SELECT:
17465 case SELF:
17466 case SET:
17467 case SPACE:
17468 case SQL:
17469 case SQLCODE:
17470 case SQLERRM:
17471 case STATIC:
17472 case SUBTYPE:
17473 case SUBSTITUTABLE:
17474 case SUCCESSFUL:
17475 case SYSDATE:
17476 case SYS_REFCURSOR:
17477 case TEMPORARY:
17478 case TIME:
17479 case TIMESTAMP:
17480 case TIMEZONE_REGION:
17481 case TIMEZONE_ABBR:
17482 case TIMEZONE_MINUTE:
17483 case TIMEZONE_HOUR:
17484 case TRANSACTION:
17485 case TRUE:
17486 case TYPE:
17487 case UNDER:
17488 case USING:
17489 case YES:
17490 case SHOW:
17491 case A:
17492 case DOUBLE:
17493 case DEC:
17494 case PRECISION:
17495 case INT:
17496 case NUMERIC:
17497 case NCHAR:
17498 case NVARCHAR2:
17499 case STRING:
17500 case UROWID:
17501 case VARRAY:
17502 case VARYING:
17503 case BFILE:
17504 case BLOB:
17505 case CLOB:
17506 case NCLOB:
17507 case YEAR:
17508 case LOCAL:
17509 case WITH:
17510 case ZONE:
17511 case CHARACTER:
17512 case AFTER:
17513 case BEFORE:
17514 case OLD:
17515 case PARENT:
17516 case ANALYZE:
17517 case ASSOCIATE:
17518 case AUDIT:
17519 case COMPOUND:
17520 case DATABASE:
17521 case CALL:
17522 case DDL:
17523 case DISASSOCIATE:
17524 case EACH:
17525 case FOLLOWS:
17526 case LOGOFF:
17527 case LOGON:
17528 case NESTED:
17529 case NOAUDIT:
17530 case SCHEMA:
17531 case SERVERERROR:
17532 case SHUTDOWN:
17533 case STARTUP:
17534 case STATEMENT:
17535 case STATISTICS:
17536 case SUSPEND:
17537 case TRUNCATE:
17538 case WRAPPED:
17539 case LIBRARY:
17540 case NAME:
17541 case STRUCT:
17542 case CONTEXT:
17543 case PARAMETERS:
17544 case LENGTH:
17545 case TDO:
17546 case MAXLEN:
17547 case CHARSETID:
17548 case CHARSETFORM:
17549 case ACCEPT:
17550 case ACCESSIBLE:
17551 case COPY:
17552 case DEFINE:
17553 case DISCONNECT:
17554 case HOST:
17555 case PRINT:
17556 case QUIT:
17557 case REMARK:
17558 case UNDEFINE:
17559 case VARIABLE:
17560 case WHENEVER:
17561 case ATTACH:
17562 case CAST:
17563 case TREAT:
17564 case TRIM:
17565 case LEFT:
17566 case RIGHT:
17567 case BOTH:
17568 case EMPTY:
17569 case MULTISET:
17570 case SUBMULTISET:
17571 case LEADING:
17572 case TRAILING:
17573 case CHAR_CS:
17574 case NCHAR_CS:
17575 case DBTIMEZONE:
17576 case SESSIONTIMEZONE:
17577 case AUTHENTICATED:
17578 case LINK:
17579 case SHARED:
17580 case DIRECTORY:
17581 case USER:
17582 case IDENTIFIER:
17583 case UNSIGNED_NUMERIC_LITERAL:
17584 case CHARACTER_LITERAL:
17585 case STRING_LITERAL:
17586 case QUOTED_LITERAL:
17587 simpleNode = StringExpression();
17588 sb.append(" "); sb.append(simpleNode.getImage());
17589 break;
17590 default:
17591 jj_la1[224] = jj_gen;
17592 ;
17593 }
17594 jj_consume_token(FROM);
17595 sb.append(thisToken.image);
17596 simpleNode = StringExpression();
17597 sb.append(" "); sb.append(simpleNode.getImage());
17598 jj_consume_token(7);
17599 sb.append(")");
17600 jjtree.closeNodeScope(jjtn000, true);
17601 jjtc000 = false;
17602 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17603 } catch (Throwable jjte000) {
17604 if (jjtc000) {
17605 jjtree.clearNodeScope(jjtn000);
17606 jjtc000 = false;
17607 } else {
17608 jjtree.popNode();
17609 }
17610 if (jjte000 instanceof RuntimeException) {
17611 {if (true) throw (RuntimeException)jjte000;}
17612 }
17613 if (jjte000 instanceof ParseException) {
17614 {if (true) throw (ParseException)jjte000;}
17615 }
17616 {if (true) throw (Error)jjte000;}
17617 } finally {
17618 if (jjtc000) {
17619 jjtree.closeNodeScope(jjtn000, true);
17620 }
17621 }
17622 throw new Error("Missing return statement in function");
17623 }
17624
17625
17626
17627
17628
17629 final public ASTObjectExpression ObjectExpression() throws ParseException {
17630
17631 ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17632 boolean jjtc000 = true;
17633 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17634 try {
17635 switch (jj_nt.kind) {
17636 case CAST:
17637 thisToken = jj_consume_token(CAST);
17638 break;
17639 case TREAT:
17640 thisToken = jj_consume_token(TREAT);
17641 break;
17642 default:
17643 jj_la1[225] = jj_gen;
17644 jj_consume_token(-1);
17645 throw new ParseException();
17646 }
17647 sb.append(thisToken.image);
17648 jj_consume_token(5);
17649 sb.append("(");
17650 simpleNode = Expression();
17651 sb.append(" "); sb.append(simpleNode.getImage());
17652 switch (jj_nt.kind) {
17653 case AT:
17654 jj_consume_token(AT);
17655 jj_consume_token(TIME);
17656 jj_consume_token(ZONE);
17657 simpleNode = PrimaryExpression();
17658 sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17659 break;
17660 default:
17661 jj_la1[226] = jj_gen;
17662 ;
17663 }
17664 jj_consume_token(AS);
17665 sb.append(" AS ");
17666 simpleNode = Datatype();
17667 sb.append(" "); sb.append(simpleNode.getImage());
17668 jj_consume_token(7);
17669 sb.append(")");
17670 label_53:
17671 while (true) {
17672 switch (jj_nt.kind) {
17673 case 3:
17674 ;
17675 break;
17676 default:
17677 jj_la1[227] = jj_gen;
17678 break label_53;
17679 }
17680 jj_consume_token(3);
17681 Expression();
17682 }
17683 jjtree.closeNodeScope(jjtn000, true);
17684 jjtc000 = false;
17685 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17686 } catch (Throwable jjte000) {
17687 if (jjtc000) {
17688 jjtree.clearNodeScope(jjtn000);
17689 jjtc000 = false;
17690 } else {
17691 jjtree.popNode();
17692 }
17693 if (jjte000 instanceof RuntimeException) {
17694 {if (true) throw (RuntimeException)jjte000;}
17695 }
17696 if (jjte000 instanceof ParseException) {
17697 {if (true) throw (ParseException)jjte000;}
17698 }
17699 {if (true) throw (Error)jjte000;}
17700 } finally {
17701 if (jjtc000) {
17702 jjtree.closeNodeScope(jjtn000, true);
17703 }
17704 }
17705 throw new Error("Missing return statement in function");
17706 }
17707
17708 final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17709
17710 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17711 boolean jjtc000 = true;
17712 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17713 try {
17714 simpleNode = ConditionalAndExpression();
17715 sb.append(simpleNode.getImage());
17716 label_54:
17717 while (true) {
17718 switch (jj_nt.kind) {
17719 case OR:
17720 ;
17721 break;
17722 default:
17723 jj_la1[228] = jj_gen;
17724 break label_54;
17725 }
17726 jj_consume_token(OR);
17727 sb.append(" OR ");
17728 simpleNode = ConditionalAndExpression();
17729 sb.append(simpleNode.getImage());
17730 }
17731 jjtree.closeNodeScope(jjtn000, true);
17732 jjtc000 = false;
17733 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17734 } catch (Throwable jjte000) {
17735 if (jjtc000) {
17736 jjtree.clearNodeScope(jjtn000);
17737 jjtc000 = false;
17738 } else {
17739 jjtree.popNode();
17740 }
17741 if (jjte000 instanceof RuntimeException) {
17742 {if (true) throw (RuntimeException)jjte000;}
17743 }
17744 if (jjte000 instanceof ParseException) {
17745 {if (true) throw (ParseException)jjte000;}
17746 }
17747 {if (true) throw (Error)jjte000;}
17748 } finally {
17749 if (jjtc000) {
17750 jjtree.closeNodeScope(jjtn000, true);
17751 }
17752 }
17753 throw new Error("Missing return statement in function");
17754 }
17755
17756 final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17757
17758 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17759 boolean jjtc000 = true;
17760 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17761 try {
17762 simpleNode = EqualityExpression();
17763 sb.append(simpleNode.getImage());
17764 label_55:
17765 while (true) {
17766 switch (jj_nt.kind) {
17767 case AND:
17768 ;
17769 break;
17770 default:
17771 jj_la1[229] = jj_gen;
17772 break label_55;
17773 }
17774 jj_consume_token(AND);
17775 sb.append(" AND ");
17776 simpleNode = EqualityExpression();
17777 sb.append(simpleNode.getImage());
17778 }
17779 jjtree.closeNodeScope(jjtn000, true);
17780 jjtc000 = false;
17781 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17782 } catch (Throwable jjte000) {
17783 if (jjtc000) {
17784 jjtree.clearNodeScope(jjtn000);
17785 jjtc000 = false;
17786 } else {
17787 jjtree.popNode();
17788 }
17789 if (jjte000 instanceof RuntimeException) {
17790 {if (true) throw (RuntimeException)jjte000;}
17791 }
17792 if (jjte000 instanceof ParseException) {
17793 {if (true) throw (ParseException)jjte000;}
17794 }
17795 {if (true) throw (Error)jjte000;}
17796 } finally {
17797 if (jjtc000) {
17798 jjtree.closeNodeScope(jjtn000, true);
17799 }
17800 }
17801 throw new Error("Missing return statement in function");
17802 }
17803
17804 final public ASTEqualityExpression EqualityExpression() throws ParseException {
17805
17806 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17807 boolean jjtc000 = true;
17808 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17809 try {
17810 simpleNode = RelationalExpression();
17811 sb.append(simpleNode.getImage());
17812 label_56:
17813 while (true) {
17814 switch (jj_nt.kind) {
17815 case 10:
17816 case 13:
17817 case IS:
17818 ;
17819 break;
17820 default:
17821 jj_la1[230] = jj_gen;
17822 break label_56;
17823 }
17824 switch (jj_nt.kind) {
17825 case 10:
17826 jj_consume_token(10);
17827 sb.append(" = ");
17828 break;
17829 case 13:
17830 jj_consume_token(13);
17831 jj_consume_token(10);
17832 sb.append(" != ");
17833 break;
17834 case IS:
17835 jj_consume_token(IS);
17836 sb.append(" IS ");
17837 break;
17838 default:
17839 jj_la1[231] = jj_gen;
17840 jj_consume_token(-1);
17841 throw new ParseException();
17842 }
17843 simpleNode = RelationalExpression();
17844 sb.append(simpleNode.getImage());
17845 }
17846 jjtree.closeNodeScope(jjtn000, true);
17847 jjtc000 = false;
17848 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17849 } catch (Throwable jjte000) {
17850 if (jjtc000) {
17851 jjtree.clearNodeScope(jjtn000);
17852 jjtc000 = false;
17853 } else {
17854 jjtree.popNode();
17855 }
17856 if (jjte000 instanceof RuntimeException) {
17857 {if (true) throw (RuntimeException)jjte000;}
17858 }
17859 if (jjte000 instanceof ParseException) {
17860 {if (true) throw (ParseException)jjte000;}
17861 }
17862 {if (true) throw (Error)jjte000;}
17863 } finally {
17864 if (jjtc000) {
17865 jjtree.closeNodeScope(jjtn000, true);
17866 }
17867 }
17868 throw new Error("Missing return statement in function");
17869 }
17870
17871
17872
17873
17874 final public ASTRelationalExpression RelationalExpression() throws ParseException {
17875
17876 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17877 boolean jjtc000 = true;
17878 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17879 try {
17880 simpleNode = AdditiveExpression();
17881 sb.append(simpleNode.getImage());
17882 label_57:
17883 while (true) {
17884 switch (jj_nt.kind) {
17885 case 14:
17886 case 15:
17887 case BETWEEN:
17888 case FROM:
17889 case IN:
17890 case LIKE:
17891 case MEMBER:
17892 case NOT:
17893 case MULTISET:
17894 case SUBMULTISET:
17895 ;
17896 break;
17897 default:
17898 jj_la1[232] = jj_gen;
17899 break label_57;
17900 }
17901 switch (jj_nt.kind) {
17902 case 14:
17903 case 15:
17904 switch (jj_nt.kind) {
17905 case 14:
17906 jj_consume_token(14);
17907 sb.append("<");
17908 switch (jj_nt.kind) {
17909 case 15:
17910 jj_consume_token(15);
17911 sb.append(">");
17912 break;
17913 default:
17914 jj_la1[233] = jj_gen;
17915 ;
17916 }
17917 break;
17918 case 15:
17919 jj_consume_token(15);
17920 sb.append(">");
17921 break;
17922 default:
17923 jj_la1[234] = jj_gen;
17924 jj_consume_token(-1);
17925 throw new ParseException();
17926 }
17927 switch (jj_nt.kind) {
17928 case 10:
17929 jj_consume_token(10);
17930 sb.append("=");
17931 break;
17932 default:
17933 jj_la1[235] = jj_gen;
17934 ;
17935 }
17936 sb.append(" ");
17937 break;
17938 case BETWEEN:
17939 case FROM:
17940 case IN:
17941 case LIKE:
17942 case MEMBER:
17943 case NOT:
17944 case SUBMULTISET:
17945 switch (jj_nt.kind) {
17946 case NOT:
17947 jj_consume_token(NOT);
17948 sb.append(" NOT ");
17949 break;
17950 default:
17951 jj_la1[236] = jj_gen;
17952 ;
17953 }
17954 switch (jj_nt.kind) {
17955 case IN:
17956 jj_consume_token(IN);
17957 sb.append(" IN ");
17958 break;
17959 case BETWEEN:
17960 jj_consume_token(BETWEEN);
17961 sb.append(" BETWEEN ");
17962 break;
17963 case LIKE:
17964 jj_consume_token(LIKE);
17965 sb.append(" LIKE ");
17966 break;
17967 case FROM:
17968 jj_consume_token(FROM);
17969 sb.append(" FROM ");
17970 break;
17971 case MEMBER:
17972 case SUBMULTISET:
17973 switch (jj_nt.kind) {
17974 case MEMBER:
17975 jj_consume_token(MEMBER);
17976 sb.append(" MEMBER ");
17977 break;
17978 case SUBMULTISET:
17979 jj_consume_token(SUBMULTISET);
17980 sb.append(" SUBMULTISET ");
17981 break;
17982 default:
17983 jj_la1[237] = jj_gen;
17984 jj_consume_token(-1);
17985 throw new ParseException();
17986 }
17987 switch (jj_nt.kind) {
17988 case OF:
17989 jj_consume_token(OF);
17990 sb.append(" OF ");
17991 break;
17992 default:
17993 jj_la1[238] = jj_gen;
17994 ;
17995 }
17996 break;
17997 default:
17998 jj_la1[239] = jj_gen;
17999 jj_consume_token(-1);
18000 throw new ParseException();
18001 }
18002 break;
18003 case MULTISET:
18004 jj_consume_token(MULTISET);
18005 sb.append (" MULTISET " );
18006 switch (jj_nt.kind) {
18007 case EXCEPT:
18008 jj_consume_token(EXCEPT);
18009 sb.append (" EXCEPT " );
18010 break;
18011 case INTERSECT:
18012 jj_consume_token(INTERSECT);
18013 sb.append (" INTERSECT " );
18014 break;
18015 case UNION:
18016 jj_consume_token(UNION);
18017 sb.append (" UNION " );
18018 break;
18019 default:
18020 jj_la1[240] = jj_gen;
18021 jj_consume_token(-1);
18022 throw new ParseException();
18023 }
18024 switch (jj_nt.kind) {
18025 case ALL:
18026 case DISTINCT:
18027 switch (jj_nt.kind) {
18028 case DISTINCT:
18029 jj_consume_token(DISTINCT);
18030 sb.append (" DISTINCT " );
18031 break;
18032 case ALL:
18033 jj_consume_token(ALL);
18034 sb.append (" ALL " );
18035 break;
18036 default:
18037 jj_la1[241] = jj_gen;
18038 jj_consume_token(-1);
18039 throw new ParseException();
18040 }
18041 break;
18042 default:
18043 jj_la1[242] = jj_gen;
18044 ;
18045 }
18046 break;
18047 default:
18048 jj_la1[243] = jj_gen;
18049 jj_consume_token(-1);
18050 throw new ParseException();
18051 }
18052 AdditiveExpression();
18053 sb.append(simpleNode.getImage());
18054 switch (jj_nt.kind) {
18055 case ESCAPE:
18056 jj_consume_token(ESCAPE);
18057 sb.append(" ESCAPE ");
18058 switch (jj_nt.kind) {
18059 case CHARACTER_LITERAL:
18060 jj_consume_token(CHARACTER_LITERAL);
18061 sb.append(" "); sb.append(token.toString());
18062 break;
18063 case STRING_LITERAL:
18064 simpleNode = StringLiteral();
18065 sb.append(" "); sb.append(simpleNode.getImage());
18066 break;
18067 default:
18068 jj_la1[244] = jj_gen;
18069 jj_consume_token(-1);
18070 throw new ParseException();
18071 }
18072 break;
18073 default:
18074 jj_la1[245] = jj_gen;
18075 ;
18076 }
18077 }
18078 jjtree.closeNodeScope(jjtn000, true);
18079 jjtc000 = false;
18080 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18081 } catch (Throwable jjte000) {
18082 if (jjtc000) {
18083 jjtree.clearNodeScope(jjtn000);
18084 jjtc000 = false;
18085 } else {
18086 jjtree.popNode();
18087 }
18088 if (jjte000 instanceof RuntimeException) {
18089 {if (true) throw (RuntimeException)jjte000;}
18090 }
18091 if (jjte000 instanceof ParseException) {
18092 {if (true) throw (ParseException)jjte000;}
18093 }
18094 {if (true) throw (Error)jjte000;}
18095 } finally {
18096 if (jjtc000) {
18097 jjtree.closeNodeScope(jjtn000, true);
18098 }
18099 }
18100 throw new Error("Missing return statement in function");
18101 }
18102
18103 final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18104
18105 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18106 boolean jjtc000 = true;
18107 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18108 try {
18109 simpleNode = MultiplicativeExpression();
18110 sb.append(simpleNode.getImage());
18111 label_58:
18112 while (true) {
18113 switch (jj_nt.kind) {
18114 case 16:
18115 case 17:
18116 case 18:
18117 ;
18118 break;
18119 default:
18120 jj_la1[246] = jj_gen;
18121 break label_58;
18122 }
18123 switch (jj_nt.kind) {
18124 case 16:
18125 jj_consume_token(16);
18126 sb.append(" + ");
18127 break;
18128 case 17:
18129 jj_consume_token(17);
18130 sb.append(" - ");
18131 break;
18132 case 18:
18133 jj_consume_token(18);
18134 sb.append(" || ");
18135 break;
18136 default:
18137 jj_la1[247] = jj_gen;
18138 jj_consume_token(-1);
18139 throw new ParseException();
18140 }
18141 simpleNode = MultiplicativeExpression();
18142 sb.append(simpleNode.getImage());
18143 }
18144 jjtree.closeNodeScope(jjtn000, true);
18145 jjtc000 = false;
18146 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18147 } catch (Throwable jjte000) {
18148 if (jjtc000) {
18149 jjtree.clearNodeScope(jjtn000);
18150 jjtc000 = false;
18151 } else {
18152 jjtree.popNode();
18153 }
18154 if (jjte000 instanceof RuntimeException) {
18155 {if (true) throw (RuntimeException)jjte000;}
18156 }
18157 if (jjte000 instanceof ParseException) {
18158 {if (true) throw (ParseException)jjte000;}
18159 }
18160 {if (true) throw (Error)jjte000;}
18161 } finally {
18162 if (jjtc000) {
18163 jjtree.closeNodeScope(jjtn000, true);
18164 }
18165 }
18166 throw new Error("Missing return statement in function");
18167 }
18168
18169 final public ASTStringExpression StringExpression() throws ParseException {
18170
18171 ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18172 boolean jjtc000 = true;
18173 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18174 try {
18175 simpleNode = PrimaryExpression();
18176 sb.append(simpleNode.getImage());
18177 label_59:
18178 while (true) {
18179 switch (jj_nt.kind) {
18180 case 18:
18181 ;
18182 break;
18183 default:
18184 jj_la1[248] = jj_gen;
18185 break label_59;
18186 }
18187 jj_consume_token(18);
18188 sb.append(" || ");
18189 simpleNode = PrimaryExpression();
18190 sb.append(simpleNode.getImage());
18191 }
18192 jjtree.closeNodeScope(jjtn000, true);
18193 jjtc000 = false;
18194 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18195 } catch (Throwable jjte000) {
18196 if (jjtc000) {
18197 jjtree.clearNodeScope(jjtn000);
18198 jjtc000 = false;
18199 } else {
18200 jjtree.popNode();
18201 }
18202 if (jjte000 instanceof RuntimeException) {
18203 {if (true) throw (RuntimeException)jjte000;}
18204 }
18205 if (jjte000 instanceof ParseException) {
18206 {if (true) throw (ParseException)jjte000;}
18207 }
18208 {if (true) throw (Error)jjte000;}
18209 } finally {
18210 if (jjtc000) {
18211 jjtree.closeNodeScope(jjtn000, true);
18212 }
18213 }
18214 throw new Error("Missing return statement in function");
18215 }
18216
18217 final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18218
18219 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18220 boolean jjtc000 = true;
18221 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18222 try {
18223 simpleNode = UnaryExpression(true);
18224 sb.append(simpleNode.getImage());
18225 label_60:
18226 while (true) {
18227 switch (jj_nt.kind) {
18228 case 1:
18229 case 19:
18230 case 20:
18231 case MOD:
18232 ;
18233 break;
18234 default:
18235 jj_la1[249] = jj_gen;
18236 break label_60;
18237 }
18238 switch (jj_nt.kind) {
18239 case 19:
18240 jj_consume_token(19);
18241 sb.append(" ** ");
18242 break;
18243 case 20:
18244 jj_consume_token(20);
18245 sb.append(" * ");
18246 break;
18247 case 1:
18248 jj_consume_token(1);
18249 sb.append(" / ");
18250 break;
18251 case MOD:
18252 jj_consume_token(MOD);
18253 sb.append(" MOD ");
18254 break;
18255 default:
18256 jj_la1[250] = jj_gen;
18257 jj_consume_token(-1);
18258 throw new ParseException();
18259 }
18260 simpleNode = UnaryExpression(true);
18261 sb.append(simpleNode.getImage());
18262 }
18263 jjtree.closeNodeScope(jjtn000, true);
18264 jjtc000 = false;
18265 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18266 } catch (Throwable jjte000) {
18267 if (jjtc000) {
18268 jjtree.clearNodeScope(jjtn000);
18269 jjtc000 = false;
18270 } else {
18271 jjtree.popNode();
18272 }
18273 if (jjte000 instanceof RuntimeException) {
18274 {if (true) throw (RuntimeException)jjte000;}
18275 }
18276 if (jjte000 instanceof ParseException) {
18277 {if (true) throw (ParseException)jjte000;}
18278 }
18279 {if (true) throw (Error)jjte000;}
18280 } finally {
18281 if (jjtc000) {
18282 jjtree.closeNodeScope(jjtn000, true);
18283 }
18284 }
18285 throw new Error("Missing return statement in function");
18286 }
18287
18288 final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18289
18290 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18291 boolean jjtc000 = true;
18292 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18293 try {
18294 switch (jj_nt.kind) {
18295 case 16:
18296 case 17:
18297 switch (jj_nt.kind) {
18298 case 16:
18299 jj_consume_token(16);
18300 sb.append(isUnarySign ? " +" : " + ");
18301 break;
18302 case 17:
18303 jj_consume_token(17);
18304 sb.append(isUnarySign ? " -" : " - ");
18305 break;
18306 default:
18307 jj_la1[251] = jj_gen;
18308 jj_consume_token(-1);
18309 throw new ParseException();
18310 }
18311 simpleNode = UnaryExpression(false);
18312 sb.append(simpleNode.getImage());
18313 break;
18314 case 5:
18315 case REPLACE:
18316 case DEFINER:
18317 case CURRENT_USER:
18318 case LANGUAGE:
18319 case INLINE:
18320 case ADD:
18321 case AGGREGATE:
18322 case ARRAY:
18323 case AT:
18324 case ATTRIBUTE:
18325 case AUTHID:
18326 case BODY:
18327 case BULK:
18328 case BYTE:
18329 case CASCADE:
18330 case CASE:
18331 case CLOSE:
18332 case COALESCE:
18333 case COLLECT:
18334 case COLUMN:
18335 case COMMENT:
18336 case COMMIT:
18337 case CONSTRUCTOR:
18338 case CONTINUE:
18339 case CONVERT:
18340 case CURRENT:
18341 case CURSOR:
18342 case DATA:
18343 case DATE:
18344 case DAY:
18345 case DISABLE:
18346 case EDITIONABLE:
18347 case ELEMENT:
18348 case ENABLE:
18349 case ESCAPE:
18350 case EXCEPT:
18351 case EXCEPTIONS:
18352 case EXIT:
18353 case EXTERNAL:
18354 case EXTENDS:
18355 case EXTRACT:
18356 case FALSE:
18357 case FINAL:
18358 case FORCE:
18359 case FUNCTION:
18360 case GLOBAL:
18361 case HASH:
18362 case HEAP:
18363 case HOUR:
18364 case IMMEDIATE:
18365 case INDICES:
18366 case INDEXTYPE:
18367 case INDICATOR:
18368 case INSTANTIABLE:
18369 case INTERVAL:
18370 case INVALIDATE:
18371 case ISOLATION:
18372 case JAVA:
18373 case LEVEL:
18374 case LIMIT:
18375 case LOOP:
18376 case MAP:
18377 case MAX:
18378 case MEMBER:
18379 case MERGE:
18380 case MIN:
18381 case MINUTE:
18382 case MLSLABEL:
18383 case MODIFY:
18384 case MOD:
18385 case MONTH:
18386 case NATURAL:
18387 case NEW:
18388 case NEW_DOT:
18389 case NO:
18390 case NONEDITIONABLE:
18391 case NOT:
18392 case NULL:
18393 case NULLIF:
18394 case OBJECT:
18395 case OID:
18396 case OPAQUE:
18397 case OPEN:
18398 case OPERATOR:
18399 case ORGANIZATION:
18400 case OTHERS:
18401 case OVERRIDING:
18402 case PACKAGE:
18403 case PARTITION:
18404 case PRESERVE:
18405 case PRIVATE:
18406 case PROCEDURE:
18407 case RANGE:
18408 case RAW:
18409 case REAL:
18410 case RECORD:
18411 case REF:
18412 case RELEASE:
18413 case RELIES_ON:
18414 case RENAME:
18415 case RESULT:
18416 case RETURN:
18417 case RETURNING:
18418 case REVERSE:
18419 case ROLLBACK:
18420 case ROW:
18421 case ROWS:
18422 case ROWID:
18423 case ROWNUM:
18424 case SAVE:
18425 case SAVEPOINT:
18426 case SECOND:
18427 case SELECT:
18428 case SELF:
18429 case SET:
18430 case SPACE:
18431 case SQL:
18432 case SQLCODE:
18433 case SQLERRM:
18434 case STATIC:
18435 case SUBTYPE:
18436 case SUBSTITUTABLE:
18437 case SUCCESSFUL:
18438 case SYSDATE:
18439 case SYS_REFCURSOR:
18440 case TEMPORARY:
18441 case TIME:
18442 case TIMESTAMP:
18443 case TIMEZONE_REGION:
18444 case TIMEZONE_ABBR:
18445 case TIMEZONE_MINUTE:
18446 case TIMEZONE_HOUR:
18447 case TRANSACTION:
18448 case TRUE:
18449 case TYPE:
18450 case UNDER:
18451 case USING:
18452 case YES:
18453 case SHOW:
18454 case A:
18455 case DOUBLE:
18456 case DEC:
18457 case PRECISION:
18458 case INT:
18459 case NUMERIC:
18460 case NCHAR:
18461 case NVARCHAR2:
18462 case STRING:
18463 case UROWID:
18464 case VARRAY:
18465 case VARYING:
18466 case BFILE:
18467 case BLOB:
18468 case CLOB:
18469 case NCLOB:
18470 case YEAR:
18471 case LOCAL:
18472 case WITH:
18473 case ZONE:
18474 case CHARACTER:
18475 case AFTER:
18476 case BEFORE:
18477 case OLD:
18478 case PARENT:
18479 case ANALYZE:
18480 case ASSOCIATE:
18481 case AUDIT:
18482 case COMPOUND:
18483 case DATABASE:
18484 case CALL:
18485 case DDL:
18486 case DISASSOCIATE:
18487 case EACH:
18488 case FOLLOWS:
18489 case LOGOFF:
18490 case LOGON:
18491 case NESTED:
18492 case NOAUDIT:
18493 case SCHEMA:
18494 case SERVERERROR:
18495 case SHUTDOWN:
18496 case STARTUP:
18497 case STATEMENT:
18498 case STATISTICS:
18499 case SUSPEND:
18500 case TRUNCATE:
18501 case WRAPPED:
18502 case LIBRARY:
18503 case NAME:
18504 case STRUCT:
18505 case CONTEXT:
18506 case PARAMETERS:
18507 case LENGTH:
18508 case TDO:
18509 case MAXLEN:
18510 case CHARSETID:
18511 case CHARSETFORM:
18512 case ACCEPT:
18513 case ACCESSIBLE:
18514 case COPY:
18515 case DEFINE:
18516 case DISCONNECT:
18517 case HOST:
18518 case PRINT:
18519 case QUIT:
18520 case REMARK:
18521 case UNDEFINE:
18522 case VARIABLE:
18523 case WHENEVER:
18524 case ATTACH:
18525 case CAST:
18526 case TREAT:
18527 case TRIM:
18528 case LEFT:
18529 case RIGHT:
18530 case BOTH:
18531 case EMPTY:
18532 case MULTISET:
18533 case SUBMULTISET:
18534 case LEADING:
18535 case TRAILING:
18536 case CHAR_CS:
18537 case NCHAR_CS:
18538 case DBTIMEZONE:
18539 case SESSIONTIMEZONE:
18540 case AUTHENTICATED:
18541 case LINK:
18542 case SHARED:
18543 case DIRECTORY:
18544 case USER:
18545 case IDENTIFIER:
18546 case UNSIGNED_NUMERIC_LITERAL:
18547 case CHARACTER_LITERAL:
18548 case STRING_LITERAL:
18549 case QUOTED_LITERAL:
18550 simpleNode = UnaryExpressionNotPlusMinus();
18551 sb.append(simpleNode.getImage());
18552 break;
18553 default:
18554 jj_la1[252] = jj_gen;
18555 jj_consume_token(-1);
18556 throw new ParseException();
18557 }
18558 jjtree.closeNodeScope(jjtn000, true);
18559 jjtc000 = false;
18560 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18561 } catch (Throwable jjte000) {
18562 if (jjtc000) {
18563 jjtree.clearNodeScope(jjtn000);
18564 jjtc000 = false;
18565 } else {
18566 jjtree.popNode();
18567 }
18568 if (jjte000 instanceof RuntimeException) {
18569 {if (true) throw (RuntimeException)jjte000;}
18570 }
18571 if (jjte000 instanceof ParseException) {
18572 {if (true) throw (ParseException)jjte000;}
18573 }
18574 {if (true) throw (Error)jjte000;}
18575 } finally {
18576 if (jjtc000) {
18577 jjtree.closeNodeScope(jjtn000, true);
18578 }
18579 }
18580 throw new Error("Missing return statement in function");
18581 }
18582
18583 final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18584
18585 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18586 boolean jjtc000 = true;
18587 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18588 try {
18589 switch (jj_nt.kind) {
18590 case NOT:
18591 jj_consume_token(NOT);
18592 sb.append(" NOT ");
18593 simpleNode = UnaryExpression(false);
18594 sb.append(simpleNode.getImage());
18595 break;
18596 case 5:
18597 case REPLACE:
18598 case DEFINER:
18599 case CURRENT_USER:
18600 case LANGUAGE:
18601 case INLINE:
18602 case ADD:
18603 case AGGREGATE:
18604 case ARRAY:
18605 case AT:
18606 case ATTRIBUTE:
18607 case AUTHID:
18608 case BODY:
18609 case BULK:
18610 case BYTE:
18611 case CASCADE:
18612 case CASE:
18613 case CLOSE:
18614 case COALESCE:
18615 case COLLECT:
18616 case COLUMN:
18617 case COMMENT:
18618 case COMMIT:
18619 case CONSTRUCTOR:
18620 case CONTINUE:
18621 case CONVERT:
18622 case CURRENT:
18623 case CURSOR:
18624 case DATA:
18625 case DATE:
18626 case DAY:
18627 case DISABLE:
18628 case EDITIONABLE:
18629 case ELEMENT:
18630 case ENABLE:
18631 case ESCAPE:
18632 case EXCEPT:
18633 case EXCEPTIONS:
18634 case EXIT:
18635 case EXTERNAL:
18636 case EXTENDS:
18637 case EXTRACT:
18638 case FALSE:
18639 case FINAL:
18640 case FORCE:
18641 case FUNCTION:
18642 case GLOBAL:
18643 case HASH:
18644 case HEAP:
18645 case HOUR:
18646 case IMMEDIATE:
18647 case INDICES:
18648 case INDEXTYPE:
18649 case INDICATOR:
18650 case INSTANTIABLE:
18651 case INTERVAL:
18652 case INVALIDATE:
18653 case ISOLATION:
18654 case JAVA:
18655 case LEVEL:
18656 case LIMIT:
18657 case LOOP:
18658 case MAP:
18659 case MAX:
18660 case MEMBER:
18661 case MERGE:
18662 case MIN:
18663 case MINUTE:
18664 case MLSLABEL:
18665 case MODIFY:
18666 case MOD:
18667 case MONTH:
18668 case NATURAL:
18669 case NEW:
18670 case NEW_DOT:
18671 case NO:
18672 case NONEDITIONABLE:
18673 case NULL:
18674 case NULLIF:
18675 case OBJECT:
18676 case OID:
18677 case OPAQUE:
18678 case OPEN:
18679 case OPERATOR:
18680 case ORGANIZATION:
18681 case OTHERS:
18682 case OVERRIDING:
18683 case PACKAGE:
18684 case PARTITION:
18685 case PRESERVE:
18686 case PRIVATE:
18687 case PROCEDURE:
18688 case RANGE:
18689 case RAW:
18690 case REAL:
18691 case RECORD:
18692 case REF:
18693 case RELEASE:
18694 case RELIES_ON:
18695 case RENAME:
18696 case RESULT:
18697 case RETURN:
18698 case RETURNING:
18699 case REVERSE:
18700 case ROLLBACK:
18701 case ROW:
18702 case ROWS:
18703 case ROWID:
18704 case ROWNUM:
18705 case SAVE:
18706 case SAVEPOINT:
18707 case SECOND:
18708 case SELECT:
18709 case SELF:
18710 case SET:
18711 case SPACE:
18712 case SQL:
18713 case SQLCODE:
18714 case SQLERRM:
18715 case STATIC:
18716 case SUBTYPE:
18717 case SUBSTITUTABLE:
18718 case SUCCESSFUL:
18719 case SYSDATE:
18720 case SYS_REFCURSOR:
18721 case TEMPORARY:
18722 case TIME:
18723 case TIMESTAMP:
18724 case TIMEZONE_REGION:
18725 case TIMEZONE_ABBR:
18726 case TIMEZONE_MINUTE:
18727 case TIMEZONE_HOUR:
18728 case TRANSACTION:
18729 case TRUE:
18730 case TYPE:
18731 case UNDER:
18732 case USING:
18733 case YES:
18734 case SHOW:
18735 case A:
18736 case DOUBLE:
18737 case DEC:
18738 case PRECISION:
18739 case INT:
18740 case NUMERIC:
18741 case NCHAR:
18742 case NVARCHAR2:
18743 case STRING:
18744 case UROWID:
18745 case VARRAY:
18746 case VARYING:
18747 case BFILE:
18748 case BLOB:
18749 case CLOB:
18750 case NCLOB:
18751 case YEAR:
18752 case LOCAL:
18753 case WITH:
18754 case ZONE:
18755 case CHARACTER:
18756 case AFTER:
18757 case BEFORE:
18758 case OLD:
18759 case PARENT:
18760 case ANALYZE:
18761 case ASSOCIATE:
18762 case AUDIT:
18763 case COMPOUND:
18764 case DATABASE:
18765 case CALL:
18766 case DDL:
18767 case DISASSOCIATE:
18768 case EACH:
18769 case FOLLOWS:
18770 case LOGOFF:
18771 case LOGON:
18772 case NESTED:
18773 case NOAUDIT:
18774 case SCHEMA:
18775 case SERVERERROR:
18776 case SHUTDOWN:
18777 case STARTUP:
18778 case STATEMENT:
18779 case STATISTICS:
18780 case SUSPEND:
18781 case TRUNCATE:
18782 case WRAPPED:
18783 case LIBRARY:
18784 case NAME:
18785 case STRUCT:
18786 case CONTEXT:
18787 case PARAMETERS:
18788 case LENGTH:
18789 case TDO:
18790 case MAXLEN:
18791 case CHARSETID:
18792 case CHARSETFORM:
18793 case ACCEPT:
18794 case ACCESSIBLE:
18795 case COPY:
18796 case DEFINE:
18797 case DISCONNECT:
18798 case HOST:
18799 case PRINT:
18800 case QUIT:
18801 case REMARK:
18802 case UNDEFINE:
18803 case VARIABLE:
18804 case WHENEVER:
18805 case ATTACH:
18806 case CAST:
18807 case TREAT:
18808 case TRIM:
18809 case LEFT:
18810 case RIGHT:
18811 case BOTH:
18812 case EMPTY:
18813 case MULTISET:
18814 case SUBMULTISET:
18815 case LEADING:
18816 case TRAILING:
18817 case CHAR_CS:
18818 case NCHAR_CS:
18819 case DBTIMEZONE:
18820 case SESSIONTIMEZONE:
18821 case AUTHENTICATED:
18822 case LINK:
18823 case SHARED:
18824 case DIRECTORY:
18825 case USER:
18826 case IDENTIFIER:
18827 case UNSIGNED_NUMERIC_LITERAL:
18828 case CHARACTER_LITERAL:
18829 case STRING_LITERAL:
18830 case QUOTED_LITERAL:
18831 simpleNode = IsNullCondition();
18832 sb.append(simpleNode.getImage());
18833 break;
18834 default:
18835 jj_la1[253] = jj_gen;
18836 jj_consume_token(-1);
18837 throw new ParseException();
18838 }
18839 jjtree.closeNodeScope(jjtn000, true);
18840 jjtc000 = false;
18841 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18842 } catch (Throwable jjte000) {
18843 if (jjtc000) {
18844 jjtree.clearNodeScope(jjtn000);
18845 jjtc000 = false;
18846 } else {
18847 jjtree.popNode();
18848 }
18849 if (jjte000 instanceof RuntimeException) {
18850 {if (true) throw (RuntimeException)jjte000;}
18851 }
18852 if (jjte000 instanceof ParseException) {
18853 {if (true) throw (ParseException)jjte000;}
18854 }
18855 {if (true) throw (Error)jjte000;}
18856 } finally {
18857 if (jjtc000) {
18858 jjtree.closeNodeScope(jjtn000, true);
18859 }
18860 }
18861 throw new Error("Missing return statement in function");
18862 }
18863
18864 final public ASTIsNullCondition IsNullCondition() throws ParseException {
18865
18866 ASTIsNullCondition jjtn000 = new ASTIsNullCondition(this, JJTISNULLCONDITION);
18867 boolean jjtc000 = true;
18868 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
18869 try {
18870 if (jj_2_46(2147483647)) {
18871 name = Name();
18872 sb.append(name.getImage());
18873 jj_consume_token(IS);
18874 sb.append(" IS");
18875 switch (jj_nt.kind) {
18876 case NOT:
18877 jj_consume_token(NOT);
18878 sb.append(" NOT");
18879 break;
18880 default:
18881 jj_la1[254] = jj_gen;
18882 ;
18883 }
18884 jj_consume_token(NULL);
18885 sb.append(" NULL");
18886 } else {
18887 switch (jj_nt.kind) {
18888 case 5:
18889 case REPLACE:
18890 case DEFINER:
18891 case CURRENT_USER:
18892 case LANGUAGE:
18893 case INLINE:
18894 case ADD:
18895 case AGGREGATE:
18896 case ARRAY:
18897 case AT:
18898 case ATTRIBUTE:
18899 case AUTHID:
18900 case BODY:
18901 case BULK:
18902 case BYTE:
18903 case CASCADE:
18904 case CASE:
18905 case CLOSE:
18906 case COALESCE:
18907 case COLLECT:
18908 case COLUMN:
18909 case COMMENT:
18910 case COMMIT:
18911 case CONSTRUCTOR:
18912 case CONTINUE:
18913 case CONVERT:
18914 case CURRENT:
18915 case CURSOR:
18916 case DATA:
18917 case DATE:
18918 case DAY:
18919 case DISABLE:
18920 case EDITIONABLE:
18921 case ELEMENT:
18922 case ENABLE:
18923 case ESCAPE:
18924 case EXCEPT:
18925 case EXCEPTIONS:
18926 case EXIT:
18927 case EXTERNAL:
18928 case EXTENDS:
18929 case EXTRACT:
18930 case FALSE:
18931 case FINAL:
18932 case FORCE:
18933 case FUNCTION:
18934 case GLOBAL:
18935 case HASH:
18936 case HEAP:
18937 case HOUR:
18938 case IMMEDIATE:
18939 case INDICES:
18940 case INDEXTYPE:
18941 case INDICATOR:
18942 case INSTANTIABLE:
18943 case INTERVAL:
18944 case INVALIDATE:
18945 case ISOLATION:
18946 case JAVA:
18947 case LEVEL:
18948 case LIMIT:
18949 case LOOP:
18950 case MAP:
18951 case MAX:
18952 case MEMBER:
18953 case MERGE:
18954 case MIN:
18955 case MINUTE:
18956 case MLSLABEL:
18957 case MODIFY:
18958 case MOD:
18959 case MONTH:
18960 case NATURAL:
18961 case NEW:
18962 case NEW_DOT:
18963 case NO:
18964 case NONEDITIONABLE:
18965 case NULL:
18966 case NULLIF:
18967 case OBJECT:
18968 case OID:
18969 case OPAQUE:
18970 case OPEN:
18971 case OPERATOR:
18972 case ORGANIZATION:
18973 case OTHERS:
18974 case OVERRIDING:
18975 case PACKAGE:
18976 case PARTITION:
18977 case PRESERVE:
18978 case PRIVATE:
18979 case PROCEDURE:
18980 case RANGE:
18981 case RAW:
18982 case REAL:
18983 case RECORD:
18984 case REF:
18985 case RELEASE:
18986 case RELIES_ON:
18987 case RENAME:
18988 case RESULT:
18989 case RETURN:
18990 case RETURNING:
18991 case REVERSE:
18992 case ROLLBACK:
18993 case ROW:
18994 case ROWS:
18995 case ROWID:
18996 case ROWNUM:
18997 case SAVE:
18998 case SAVEPOINT:
18999 case SECOND:
19000 case SELECT:
19001 case SELF:
19002 case SET:
19003 case SPACE:
19004 case SQL:
19005 case SQLCODE:
19006 case SQLERRM:
19007 case STATIC:
19008 case SUBTYPE:
19009 case SUBSTITUTABLE:
19010 case SUCCESSFUL:
19011 case SYSDATE:
19012 case SYS_REFCURSOR:
19013 case TEMPORARY:
19014 case TIME:
19015 case TIMESTAMP:
19016 case TIMEZONE_REGION:
19017 case TIMEZONE_ABBR:
19018 case TIMEZONE_MINUTE:
19019 case TIMEZONE_HOUR:
19020 case TRANSACTION:
19021 case TRUE:
19022 case TYPE:
19023 case UNDER:
19024 case USING:
19025 case YES:
19026 case SHOW:
19027 case A:
19028 case DOUBLE:
19029 case DEC:
19030 case PRECISION:
19031 case INT:
19032 case NUMERIC:
19033 case NCHAR:
19034 case NVARCHAR2:
19035 case STRING:
19036 case UROWID:
19037 case VARRAY:
19038 case VARYING:
19039 case BFILE:
19040 case BLOB:
19041 case CLOB:
19042 case NCLOB:
19043 case YEAR:
19044 case LOCAL:
19045 case WITH:
19046 case ZONE:
19047 case CHARACTER:
19048 case AFTER:
19049 case BEFORE:
19050 case OLD:
19051 case PARENT:
19052 case ANALYZE:
19053 case ASSOCIATE:
19054 case AUDIT:
19055 case COMPOUND:
19056 case DATABASE:
19057 case CALL:
19058 case DDL:
19059 case DISASSOCIATE:
19060 case EACH:
19061 case FOLLOWS:
19062 case LOGOFF:
19063 case LOGON:
19064 case NESTED:
19065 case NOAUDIT:
19066 case SCHEMA:
19067 case SERVERERROR:
19068 case SHUTDOWN:
19069 case STARTUP:
19070 case STATEMENT:
19071 case STATISTICS:
19072 case SUSPEND:
19073 case TRUNCATE:
19074 case WRAPPED:
19075 case LIBRARY:
19076 case NAME:
19077 case STRUCT:
19078 case CONTEXT:
19079 case PARAMETERS:
19080 case LENGTH:
19081 case TDO:
19082 case MAXLEN:
19083 case CHARSETID:
19084 case CHARSETFORM:
19085 case ACCEPT:
19086 case ACCESSIBLE:
19087 case COPY:
19088 case DEFINE:
19089 case DISCONNECT:
19090 case HOST:
19091 case PRINT:
19092 case QUIT:
19093 case REMARK:
19094 case UNDEFINE:
19095 case VARIABLE:
19096 case WHENEVER:
19097 case ATTACH:
19098 case CAST:
19099 case TREAT:
19100 case TRIM:
19101 case LEFT:
19102 case RIGHT:
19103 case BOTH:
19104 case EMPTY:
19105 case MULTISET:
19106 case SUBMULTISET:
19107 case LEADING:
19108 case TRAILING:
19109 case CHAR_CS:
19110 case NCHAR_CS:
19111 case DBTIMEZONE:
19112 case SESSIONTIMEZONE:
19113 case AUTHENTICATED:
19114 case LINK:
19115 case SHARED:
19116 case DIRECTORY:
19117 case USER:
19118 case IDENTIFIER:
19119 case UNSIGNED_NUMERIC_LITERAL:
19120 case CHARACTER_LITERAL:
19121 case STRING_LITERAL:
19122 case QUOTED_LITERAL:
19123 simpleNode = IsOfTypeCondition();
19124 sb.append(simpleNode.getImage());
19125 break;
19126 default:
19127 jj_la1[255] = jj_gen;
19128 jj_consume_token(-1);
19129 throw new ParseException();
19130 }
19131 }
19132 jjtree.closeNodeScope(jjtn000, true);
19133 jjtc000 = false;
19134 jjtn000.setImage(sb.toString());
19135 {if (true) return jjtn000;}
19136 } catch (Throwable jjte000) {
19137 if (jjtc000) {
19138 jjtree.clearNodeScope(jjtn000);
19139 jjtc000 = false;
19140 } else {
19141 jjtree.popNode();
19142 }
19143 if (jjte000 instanceof RuntimeException) {
19144 {if (true) throw (RuntimeException)jjte000;}
19145 }
19146 if (jjte000 instanceof ParseException) {
19147 {if (true) throw (ParseException)jjte000;}
19148 }
19149 {if (true) throw (Error)jjte000;}
19150 } finally {
19151 if (jjtc000) {
19152 jjtree.closeNodeScope(jjtn000, true);
19153 }
19154 }
19155 throw new Error("Missing return statement in function");
19156 }
19157
19158 final public ASTIsOfTypeCondition IsOfTypeCondition() throws ParseException {
19159
19160 ASTIsOfTypeCondition jjtn000 = new ASTIsOfTypeCondition(this, JJTISOFTYPECONDITION);
19161 boolean jjtc000 = true;
19162 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
19163 try {
19164 if (jj_2_47(2147483647)) {
19165 name = Name();
19166 sb.append(name.getImage());
19167 jj_consume_token(IS);
19168 sb.append(" IS");
19169 switch (jj_nt.kind) {
19170 case NOT:
19171 jj_consume_token(NOT);
19172 sb.append(" NOT");
19173 break;
19174 default:
19175 jj_la1[256] = jj_gen;
19176 ;
19177 }
19178 jj_consume_token(OF);
19179 sb.append(" OF");
19180 switch (jj_nt.kind) {
19181 case TYPE:
19182 jj_consume_token(TYPE);
19183 break;
19184 default:
19185 jj_la1[257] = jj_gen;
19186 ;
19187 }
19188 jj_consume_token(5);
19189 switch (jj_nt.kind) {
19190 case ONLY:
19191 jj_consume_token(ONLY);
19192 break;
19193 default:
19194 jj_la1[258] = jj_gen;
19195 ;
19196 }
19197 Name();
19198 label_61:
19199 while (true) {
19200 switch (jj_nt.kind) {
19201 case 6:
19202 ;
19203 break;
19204 default:
19205 jj_la1[259] = jj_gen;
19206 break label_61;
19207 }
19208 jj_consume_token(6);
19209 switch (jj_nt.kind) {
19210 case ONLY:
19211 jj_consume_token(ONLY);
19212 break;
19213 default:
19214 jj_la1[260] = jj_gen;
19215 ;
19216 }
19217 Name();
19218 }
19219 jj_consume_token(7);
19220 } else {
19221 switch (jj_nt.kind) {
19222 case 5:
19223 case REPLACE:
19224 case DEFINER:
19225 case CURRENT_USER:
19226 case LANGUAGE:
19227 case INLINE:
19228 case ADD:
19229 case AGGREGATE:
19230 case ARRAY:
19231 case AT:
19232 case ATTRIBUTE:
19233 case AUTHID:
19234 case BODY:
19235 case BULK:
19236 case BYTE:
19237 case CASCADE:
19238 case CASE:
19239 case CLOSE:
19240 case COALESCE:
19241 case COLLECT:
19242 case COLUMN:
19243 case COMMENT:
19244 case COMMIT:
19245 case CONSTRUCTOR:
19246 case CONTINUE:
19247 case CONVERT:
19248 case CURRENT:
19249 case CURSOR:
19250 case DATA:
19251 case DATE:
19252 case DAY:
19253 case DISABLE:
19254 case EDITIONABLE:
19255 case ELEMENT:
19256 case ENABLE:
19257 case ESCAPE:
19258 case EXCEPT:
19259 case EXCEPTIONS:
19260 case EXIT:
19261 case EXTERNAL:
19262 case EXTENDS:
19263 case EXTRACT:
19264 case FALSE:
19265 case FINAL:
19266 case FORCE:
19267 case FUNCTION:
19268 case GLOBAL:
19269 case HASH:
19270 case HEAP:
19271 case HOUR:
19272 case IMMEDIATE:
19273 case INDICES:
19274 case INDEXTYPE:
19275 case INDICATOR:
19276 case INSTANTIABLE:
19277 case INTERVAL:
19278 case INVALIDATE:
19279 case ISOLATION:
19280 case JAVA:
19281 case LEVEL:
19282 case LIMIT:
19283 case LOOP:
19284 case MAP:
19285 case MAX:
19286 case MEMBER:
19287 case MERGE:
19288 case MIN:
19289 case MINUTE:
19290 case MLSLABEL:
19291 case MODIFY:
19292 case MOD:
19293 case MONTH:
19294 case NATURAL:
19295 case NEW:
19296 case NEW_DOT:
19297 case NO:
19298 case NONEDITIONABLE:
19299 case NULL:
19300 case NULLIF:
19301 case OBJECT:
19302 case OID:
19303 case OPAQUE:
19304 case OPEN:
19305 case OPERATOR:
19306 case ORGANIZATION:
19307 case OTHERS:
19308 case OVERRIDING:
19309 case PACKAGE:
19310 case PARTITION:
19311 case PRESERVE:
19312 case PRIVATE:
19313 case PROCEDURE:
19314 case RANGE:
19315 case RAW:
19316 case REAL:
19317 case RECORD:
19318 case REF:
19319 case RELEASE:
19320 case RELIES_ON:
19321 case RENAME:
19322 case RESULT:
19323 case RETURN:
19324 case RETURNING:
19325 case REVERSE:
19326 case ROLLBACK:
19327 case ROW:
19328 case ROWS:
19329 case ROWID:
19330 case ROWNUM:
19331 case SAVE:
19332 case SAVEPOINT:
19333 case SECOND:
19334 case SELECT:
19335 case SELF:
19336 case SET:
19337 case SPACE:
19338 case SQL:
19339 case SQLCODE:
19340 case SQLERRM:
19341 case STATIC:
19342 case SUBTYPE:
19343 case SUBSTITUTABLE:
19344 case SUCCESSFUL:
19345 case SYSDATE:
19346 case SYS_REFCURSOR:
19347 case TEMPORARY:
19348 case TIME:
19349 case TIMESTAMP:
19350 case TIMEZONE_REGION:
19351 case TIMEZONE_ABBR:
19352 case TIMEZONE_MINUTE:
19353 case TIMEZONE_HOUR:
19354 case TRANSACTION:
19355 case TRUE:
19356 case TYPE:
19357 case UNDER:
19358 case USING:
19359 case YES:
19360 case SHOW:
19361 case A:
19362 case DOUBLE:
19363 case DEC:
19364 case PRECISION:
19365 case INT:
19366 case NUMERIC:
19367 case NCHAR:
19368 case NVARCHAR2:
19369 case STRING:
19370 case UROWID:
19371 case VARRAY:
19372 case VARYING:
19373 case BFILE:
19374 case BLOB:
19375 case CLOB:
19376 case NCLOB:
19377 case YEAR:
19378 case LOCAL:
19379 case WITH:
19380 case ZONE:
19381 case CHARACTER:
19382 case AFTER:
19383 case BEFORE:
19384 case OLD:
19385 case PARENT:
19386 case ANALYZE:
19387 case ASSOCIATE:
19388 case AUDIT:
19389 case COMPOUND:
19390 case DATABASE:
19391 case CALL:
19392 case DDL:
19393 case DISASSOCIATE:
19394 case EACH:
19395 case FOLLOWS:
19396 case LOGOFF:
19397 case LOGON:
19398 case NESTED:
19399 case NOAUDIT:
19400 case SCHEMA:
19401 case SERVERERROR:
19402 case SHUTDOWN:
19403 case STARTUP:
19404 case STATEMENT:
19405 case STATISTICS:
19406 case SUSPEND:
19407 case TRUNCATE:
19408 case WRAPPED:
19409 case LIBRARY:
19410 case NAME:
19411 case STRUCT:
19412 case CONTEXT:
19413 case PARAMETERS:
19414 case LENGTH:
19415 case TDO:
19416 case MAXLEN:
19417 case CHARSETID:
19418 case CHARSETFORM:
19419 case ACCEPT:
19420 case ACCESSIBLE:
19421 case COPY:
19422 case DEFINE:
19423 case DISCONNECT:
19424 case HOST:
19425 case PRINT:
19426 case QUIT:
19427 case REMARK:
19428 case UNDEFINE:
19429 case VARIABLE:
19430 case WHENEVER:
19431 case ATTACH:
19432 case CAST:
19433 case TREAT:
19434 case TRIM:
19435 case LEFT:
19436 case RIGHT:
19437 case BOTH:
19438 case EMPTY:
19439 case MULTISET:
19440 case SUBMULTISET:
19441 case LEADING:
19442 case TRAILING:
19443 case CHAR_CS:
19444 case NCHAR_CS:
19445 case DBTIMEZONE:
19446 case SESSIONTIMEZONE:
19447 case AUTHENTICATED:
19448 case LINK:
19449 case SHARED:
19450 case DIRECTORY:
19451 case USER:
19452 case IDENTIFIER:
19453 case UNSIGNED_NUMERIC_LITERAL:
19454 case CHARACTER_LITERAL:
19455 case STRING_LITERAL:
19456 case QUOTED_LITERAL:
19457 simpleNode = PrimaryExpression();
19458 sb.append(simpleNode.getImage());
19459 break;
19460 default:
19461 jj_la1[261] = jj_gen;
19462 jj_consume_token(-1);
19463 throw new ParseException();
19464 }
19465 }
19466 jjtree.closeNodeScope(jjtn000, true);
19467 jjtc000 = false;
19468 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19469 } catch (Throwable jjte000) {
19470 if (jjtc000) {
19471 jjtree.clearNodeScope(jjtn000);
19472 jjtc000 = false;
19473 } else {
19474 jjtree.popNode();
19475 }
19476 if (jjte000 instanceof RuntimeException) {
19477 {if (true) throw (RuntimeException)jjte000;}
19478 }
19479 if (jjte000 instanceof ParseException) {
19480 {if (true) throw (ParseException)jjte000;}
19481 }
19482 {if (true) throw (Error)jjte000;}
19483 } finally {
19484 if (jjtc000) {
19485 jjtree.closeNodeScope(jjtn000, true);
19486 }
19487 }
19488 throw new Error("Missing return statement in function");
19489 }
19490
19491
19492
19493
19494
19495
19496 final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
19497
19498 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
19499 boolean jjtc000 = true;
19500 jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19501 try {
19502 switch (jj_nt.kind) {
19503 case NEW_DOT:
19504 jj_consume_token(NEW_DOT);
19505 simpleNode = QualifiedID();
19506 sb.append(" NEW."); sb.append(simpleNode.getImage());
19507 break;
19508 case 5:
19509 case REPLACE:
19510 case DEFINER:
19511 case CURRENT_USER:
19512 case LANGUAGE:
19513 case INLINE:
19514 case ADD:
19515 case AGGREGATE:
19516 case ARRAY:
19517 case AT:
19518 case ATTRIBUTE:
19519 case AUTHID:
19520 case BODY:
19521 case BULK:
19522 case BYTE:
19523 case CASCADE:
19524 case CASE:
19525 case CLOSE:
19526 case COALESCE:
19527 case COLLECT:
19528 case COLUMN:
19529 case COMMENT:
19530 case COMMIT:
19531 case CONSTRUCTOR:
19532 case CONTINUE:
19533 case CONVERT:
19534 case CURRENT:
19535 case CURSOR:
19536 case DATA:
19537 case DATE:
19538 case DAY:
19539 case DISABLE:
19540 case EDITIONABLE:
19541 case ELEMENT:
19542 case ENABLE:
19543 case ESCAPE:
19544 case EXCEPT:
19545 case EXCEPTIONS:
19546 case EXIT:
19547 case EXTERNAL:
19548 case EXTENDS:
19549 case EXTRACT:
19550 case FALSE:
19551 case FINAL:
19552 case FORCE:
19553 case FUNCTION:
19554 case GLOBAL:
19555 case HASH:
19556 case HEAP:
19557 case HOUR:
19558 case IMMEDIATE:
19559 case INDICES:
19560 case INDEXTYPE:
19561 case INDICATOR:
19562 case INSTANTIABLE:
19563 case INTERVAL:
19564 case INVALIDATE:
19565 case ISOLATION:
19566 case JAVA:
19567 case LEVEL:
19568 case LIMIT:
19569 case LOOP:
19570 case MAP:
19571 case MAX:
19572 case MEMBER:
19573 case MERGE:
19574 case MIN:
19575 case MINUTE:
19576 case MLSLABEL:
19577 case MODIFY:
19578 case MOD:
19579 case MONTH:
19580 case NATURAL:
19581 case NEW:
19582 case NO:
19583 case NONEDITIONABLE:
19584 case NULL:
19585 case NULLIF:
19586 case OBJECT:
19587 case OID:
19588 case OPAQUE:
19589 case OPEN:
19590 case OPERATOR:
19591 case ORGANIZATION:
19592 case OTHERS:
19593 case OVERRIDING:
19594 case PACKAGE:
19595 case PARTITION:
19596 case PRESERVE:
19597 case PRIVATE:
19598 case PROCEDURE:
19599 case RANGE:
19600 case RAW:
19601 case REAL:
19602 case RECORD:
19603 case REF:
19604 case RELEASE:
19605 case RELIES_ON:
19606 case RENAME:
19607 case RESULT:
19608 case RETURN:
19609 case RETURNING:
19610 case REVERSE:
19611 case ROLLBACK:
19612 case ROW:
19613 case ROWS:
19614 case ROWID:
19615 case ROWNUM:
19616 case SAVE:
19617 case SAVEPOINT:
19618 case SECOND:
19619 case SELECT:
19620 case SELF:
19621 case SET:
19622 case SPACE:
19623 case SQL:
19624 case SQLCODE:
19625 case SQLERRM:
19626 case STATIC:
19627 case SUBTYPE:
19628 case SUBSTITUTABLE:
19629 case SUCCESSFUL:
19630 case SYSDATE:
19631 case SYS_REFCURSOR:
19632 case TEMPORARY:
19633 case TIME:
19634 case TIMESTAMP:
19635 case TIMEZONE_REGION:
19636 case TIMEZONE_ABBR:
19637 case TIMEZONE_MINUTE:
19638 case TIMEZONE_HOUR:
19639 case TRANSACTION:
19640 case TRUE:
19641 case TYPE:
19642 case UNDER:
19643 case USING:
19644 case YES:
19645 case SHOW:
19646 case A:
19647 case DOUBLE:
19648 case DEC:
19649 case PRECISION:
19650 case INT:
19651 case NUMERIC:
19652 case NCHAR:
19653 case NVARCHAR2:
19654 case STRING:
19655 case UROWID:
19656 case VARRAY:
19657 case VARYING:
19658 case BFILE:
19659 case BLOB:
19660 case CLOB:
19661 case NCLOB:
19662 case YEAR:
19663 case LOCAL:
19664 case WITH:
19665 case ZONE:
19666 case CHARACTER:
19667 case AFTER:
19668 case BEFORE:
19669 case OLD:
19670 case PARENT:
19671 case ANALYZE:
19672 case ASSOCIATE:
19673 case AUDIT:
19674 case COMPOUND:
19675 case DATABASE:
19676 case CALL:
19677 case DDL:
19678 case DISASSOCIATE:
19679 case EACH:
19680 case FOLLOWS:
19681 case LOGOFF:
19682 case LOGON:
19683 case NESTED:
19684 case NOAUDIT:
19685 case SCHEMA:
19686 case SERVERERROR:
19687 case SHUTDOWN:
19688 case STARTUP:
19689 case STATEMENT:
19690 case STATISTICS:
19691 case SUSPEND:
19692 case TRUNCATE:
19693 case WRAPPED:
19694 case LIBRARY:
19695 case NAME:
19696 case STRUCT:
19697 case CONTEXT:
19698 case PARAMETERS:
19699 case LENGTH:
19700 case TDO:
19701 case MAXLEN:
19702 case CHARSETID:
19703 case CHARSETFORM:
19704 case ACCEPT:
19705 case ACCESSIBLE:
19706 case COPY:
19707 case DEFINE:
19708 case DISCONNECT:
19709 case HOST:
19710 case PRINT:
19711 case QUIT:
19712 case REMARK:
19713 case UNDEFINE:
19714 case VARIABLE:
19715 case WHENEVER:
19716 case ATTACH:
19717 case CAST:
19718 case TREAT:
19719 case TRIM:
19720 case LEFT:
19721 case RIGHT:
19722 case BOTH:
19723 case EMPTY:
19724 case MULTISET:
19725 case SUBMULTISET:
19726 case LEADING:
19727 case TRAILING:
19728 case CHAR_CS:
19729 case NCHAR_CS:
19730 case DBTIMEZONE:
19731 case SESSIONTIMEZONE:
19732 case AUTHENTICATED:
19733 case LINK:
19734 case SHARED:
19735 case DIRECTORY:
19736 case USER:
19737 case IDENTIFIER:
19738 case UNSIGNED_NUMERIC_LITERAL:
19739 case CHARACTER_LITERAL:
19740 case STRING_LITERAL:
19741 case QUOTED_LITERAL:
19742 if (jj_2_48(2147483647)) {
19743 jj_consume_token(NEW);
19744 sb.append(" NEW ");
19745 simpleNode = PrimaryPrefix();
19746 sb.append(simpleNode.getImage());
19747 } else {
19748 switch (jj_nt.kind) {
19749 case 5:
19750 case REPLACE:
19751 case DEFINER:
19752 case CURRENT_USER:
19753 case LANGUAGE:
19754 case INLINE:
19755 case ADD:
19756 case AGGREGATE:
19757 case ARRAY:
19758 case AT:
19759 case ATTRIBUTE:
19760 case AUTHID:
19761 case BODY:
19762 case BULK:
19763 case BYTE:
19764 case CASCADE:
19765 case CASE:
19766 case CLOSE:
19767 case COALESCE:
19768 case COLLECT:
19769 case COLUMN:
19770 case COMMENT:
19771 case COMMIT:
19772 case CONSTRUCTOR:
19773 case CONTINUE:
19774 case CONVERT:
19775 case CURRENT:
19776 case CURSOR:
19777 case DATA:
19778 case DATE:
19779 case DAY:
19780 case DISABLE:
19781 case EDITIONABLE:
19782 case ELEMENT:
19783 case ENABLE:
19784 case ESCAPE:
19785 case EXCEPT:
19786 case EXCEPTIONS:
19787 case EXIT:
19788 case EXTERNAL:
19789 case EXTENDS:
19790 case EXTRACT:
19791 case FALSE:
19792 case FINAL:
19793 case FORCE:
19794 case FUNCTION:
19795 case GLOBAL:
19796 case HASH:
19797 case HEAP:
19798 case HOUR:
19799 case IMMEDIATE:
19800 case INDICES:
19801 case INDEXTYPE:
19802 case INDICATOR:
19803 case INSTANTIABLE:
19804 case INTERVAL:
19805 case INVALIDATE:
19806 case ISOLATION:
19807 case JAVA:
19808 case LEVEL:
19809 case LIMIT:
19810 case LOOP:
19811 case MAP:
19812 case MAX:
19813 case MEMBER:
19814 case MERGE:
19815 case MIN:
19816 case MINUTE:
19817 case MLSLABEL:
19818 case MODIFY:
19819 case MOD:
19820 case MONTH:
19821 case NATURAL:
19822 case NEW:
19823 case NO:
19824 case NONEDITIONABLE:
19825 case NULL:
19826 case NULLIF:
19827 case OBJECT:
19828 case OID:
19829 case OPAQUE:
19830 case OPEN:
19831 case OPERATOR:
19832 case ORGANIZATION:
19833 case OTHERS:
19834 case OVERRIDING:
19835 case PACKAGE:
19836 case PARTITION:
19837 case PRESERVE:
19838 case PRIVATE:
19839 case PROCEDURE:
19840 case RANGE:
19841 case RAW:
19842 case REAL:
19843 case RECORD:
19844 case REF:
19845 case RELEASE:
19846 case RELIES_ON:
19847 case RENAME:
19848 case RESULT:
19849 case RETURN:
19850 case RETURNING:
19851 case REVERSE:
19852 case ROLLBACK:
19853 case ROW:
19854 case ROWS:
19855 case ROWID:
19856 case ROWNUM:
19857 case SAVE:
19858 case SAVEPOINT:
19859 case SECOND:
19860 case SELECT:
19861 case SELF:
19862 case SET:
19863 case SPACE:
19864 case SQL:
19865 case SQLCODE:
19866 case SQLERRM:
19867 case STATIC:
19868 case SUBTYPE:
19869 case SUBSTITUTABLE:
19870 case SUCCESSFUL:
19871 case SYSDATE:
19872 case SYS_REFCURSOR:
19873 case TEMPORARY:
19874 case TIME:
19875 case TIMESTAMP:
19876 case TIMEZONE_REGION:
19877 case TIMEZONE_ABBR:
19878 case TIMEZONE_MINUTE:
19879 case TIMEZONE_HOUR:
19880 case TRANSACTION:
19881 case TRUE:
19882 case TYPE:
19883 case UNDER:
19884 case USING:
19885 case YES:
19886 case SHOW:
19887 case A:
19888 case DOUBLE:
19889 case DEC:
19890 case PRECISION:
19891 case INT:
19892 case NUMERIC:
19893 case NCHAR:
19894 case NVARCHAR2:
19895 case STRING:
19896 case UROWID:
19897 case VARRAY:
19898 case VARYING:
19899 case BFILE:
19900 case BLOB:
19901 case CLOB:
19902 case NCLOB:
19903 case YEAR:
19904 case LOCAL:
19905 case WITH:
19906 case ZONE:
19907 case CHARACTER:
19908 case AFTER:
19909 case BEFORE:
19910 case OLD:
19911 case PARENT:
19912 case ANALYZE:
19913 case ASSOCIATE:
19914 case AUDIT:
19915 case COMPOUND:
19916 case DATABASE:
19917 case CALL:
19918 case DDL:
19919 case DISASSOCIATE:
19920 case EACH:
19921 case FOLLOWS:
19922 case LOGOFF:
19923 case LOGON:
19924 case NESTED:
19925 case NOAUDIT:
19926 case SCHEMA:
19927 case SERVERERROR:
19928 case SHUTDOWN:
19929 case STARTUP:
19930 case STATEMENT:
19931 case STATISTICS:
19932 case SUSPEND:
19933 case TRUNCATE:
19934 case WRAPPED:
19935 case LIBRARY:
19936 case NAME:
19937 case STRUCT:
19938 case CONTEXT:
19939 case PARAMETERS:
19940 case LENGTH:
19941 case TDO:
19942 case MAXLEN:
19943 case CHARSETID:
19944 case CHARSETFORM:
19945 case ACCEPT:
19946 case ACCESSIBLE:
19947 case COPY:
19948 case DEFINE:
19949 case DISCONNECT:
19950 case HOST:
19951 case PRINT:
19952 case QUIT:
19953 case REMARK:
19954 case UNDEFINE:
19955 case VARIABLE:
19956 case WHENEVER:
19957 case ATTACH:
19958 case CAST:
19959 case TREAT:
19960 case TRIM:
19961 case LEFT:
19962 case RIGHT:
19963 case BOTH:
19964 case EMPTY:
19965 case MULTISET:
19966 case SUBMULTISET:
19967 case LEADING:
19968 case TRAILING:
19969 case CHAR_CS:
19970 case NCHAR_CS:
19971 case DBTIMEZONE:
19972 case SESSIONTIMEZONE:
19973 case AUTHENTICATED:
19974 case LINK:
19975 case SHARED:
19976 case DIRECTORY:
19977 case USER:
19978 case IDENTIFIER:
19979 case UNSIGNED_NUMERIC_LITERAL:
19980 case CHARACTER_LITERAL:
19981 case STRING_LITERAL:
19982 case QUOTED_LITERAL:
19983 simpleNode = PrimaryPrefix();
19984 sb.append(simpleNode.getImage());
19985 break;
19986 default:
19987 jj_la1[262] = jj_gen;
19988 jj_consume_token(-1);
19989 throw new ParseException();
19990 }
19991 }
19992 label_62:
19993 while (true) {
19994 if (jj_2_49(2)) {
19995 ;
19996 } else {
19997 break label_62;
19998 }
19999 simpleNode = PrimarySuffix();
20000 sb.append(simpleNode.getImage());
20001 }
20002 break;
20003 default:
20004 jj_la1[263] = jj_gen;
20005 jj_consume_token(-1);
20006 throw new ParseException();
20007 }
20008 jjtree.closeNodeScope(jjtn000, true);
20009 jjtc000 = false;
20010 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20011 } catch (Throwable jjte000) {
20012 if (jjtc000) {
20013 jjtree.clearNodeScope(jjtn000);
20014 jjtc000 = false;
20015 } else {
20016 jjtree.popNode();
20017 }
20018 if (jjte000 instanceof RuntimeException) {
20019 {if (true) throw (RuntimeException)jjte000;}
20020 }
20021 if (jjte000 instanceof ParseException) {
20022 {if (true) throw (ParseException)jjte000;}
20023 }
20024 {if (true) throw (Error)jjte000;}
20025 } finally {
20026 if (jjtc000) {
20027 jjtree.closeNodeScope(jjtn000, true);
20028 }
20029 }
20030 throw new Error("Missing return statement in function");
20031 }
20032
20033 final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
20034
20035 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
20036 boolean jjtc000 = true;
20037 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
20038 try {
20039 switch (jj_nt.kind) {
20040 case DATE:
20041 case FALSE:
20042 case INTERVAL:
20043 case NULL:
20044 case TIMESTAMP:
20045 case TRUE:
20046 case UNSIGNED_NUMERIC_LITERAL:
20047 case CHARACTER_LITERAL:
20048 case STRING_LITERAL:
20049 simpleNode = Literal();
20050 sb.append(simpleNode.getImage()) ;
20051 break;
20052 default:
20053 jj_la1[265] = jj_gen;
20054 if (jj_2_50(2147483647)) {
20055 simpleNode = MultiSetCondition();
20056 } else if (jj_2_51(2147483647)) {
20057 simpleNode = TrimExpression();
20058 } else if (jj_2_52(2147483647)) {
20059 simpleNode = CaseExpression();
20060 sb.append(simpleNode.getImage()) ;
20061 } else if (jj_2_53(2147483647)) {
20062 simpleNode = ObjectExpression();
20063 sb.append(simpleNode.getImage()) ;
20064 } else {
20065 switch (jj_nt.kind) {
20066 case REPLACE:
20067 case DEFINER:
20068 case CURRENT_USER:
20069 case LANGUAGE:
20070 case INLINE:
20071 case ADD:
20072 case AGGREGATE:
20073 case ARRAY:
20074 case AT:
20075 case ATTRIBUTE:
20076 case AUTHID:
20077 case BODY:
20078 case BULK:
20079 case BYTE:
20080 case CASCADE:
20081 case CLOSE:
20082 case COALESCE:
20083 case COLLECT:
20084 case COLUMN:
20085 case COMMENT:
20086 case COMMIT:
20087 case CONSTRUCTOR:
20088 case CONTINUE:
20089 case CONVERT:
20090 case CURRENT:
20091 case CURSOR:
20092 case DATA:
20093 case DAY:
20094 case DISABLE:
20095 case EDITIONABLE:
20096 case ELEMENT:
20097 case ENABLE:
20098 case ESCAPE:
20099 case EXCEPT:
20100 case EXCEPTIONS:
20101 case EXIT:
20102 case EXTERNAL:
20103 case EXTENDS:
20104 case EXTRACT:
20105 case FALSE:
20106 case FINAL:
20107 case FORCE:
20108 case FUNCTION:
20109 case GLOBAL:
20110 case HASH:
20111 case HEAP:
20112 case HOUR:
20113 case IMMEDIATE:
20114 case INDICES:
20115 case INDEXTYPE:
20116 case INDICATOR:
20117 case INSTANTIABLE:
20118 case INTERVAL:
20119 case INVALIDATE:
20120 case ISOLATION:
20121 case JAVA:
20122 case LEVEL:
20123 case LIMIT:
20124 case LOOP:
20125 case MAP:
20126 case MAX:
20127 case MEMBER:
20128 case MERGE:
20129 case MIN:
20130 case MINUTE:
20131 case MLSLABEL:
20132 case MODIFY:
20133 case MOD:
20134 case MONTH:
20135 case NATURAL:
20136 case NEW:
20137 case NO:
20138 case NONEDITIONABLE:
20139 case NULLIF:
20140 case OBJECT:
20141 case OID:
20142 case OPAQUE:
20143 case OPEN:
20144 case OPERATOR:
20145 case ORGANIZATION:
20146 case OTHERS:
20147 case OVERRIDING:
20148 case PACKAGE:
20149 case PARTITION:
20150 case PRESERVE:
20151 case PRIVATE:
20152 case PROCEDURE:
20153 case RANGE:
20154 case RAW:
20155 case REAL:
20156 case RECORD:
20157 case REF:
20158 case RELEASE:
20159 case RELIES_ON:
20160 case RENAME:
20161 case RESULT:
20162 case RETURN:
20163 case RETURNING:
20164 case REVERSE:
20165 case ROLLBACK:
20166 case ROW:
20167 case ROWS:
20168 case ROWID:
20169 case ROWNUM:
20170 case SAVE:
20171 case SAVEPOINT:
20172 case SECOND:
20173 case SELF:
20174 case SET:
20175 case SPACE:
20176 case SQL:
20177 case SQLCODE:
20178 case SQLERRM:
20179 case STATIC:
20180 case SUBTYPE:
20181 case SUBSTITUTABLE:
20182 case SUCCESSFUL:
20183 case SYSDATE:
20184 case SYS_REFCURSOR:
20185 case TEMPORARY:
20186 case TIME:
20187 case TIMESTAMP:
20188 case TIMEZONE_REGION:
20189 case TIMEZONE_ABBR:
20190 case TIMEZONE_MINUTE:
20191 case TIMEZONE_HOUR:
20192 case TRANSACTION:
20193 case TRUE:
20194 case TYPE:
20195 case UNDER:
20196 case USING:
20197 case YES:
20198 case SHOW:
20199 case A:
20200 case DOUBLE:
20201 case DEC:
20202 case PRECISION:
20203 case INT:
20204 case NUMERIC:
20205 case NCHAR:
20206 case NVARCHAR2:
20207 case STRING:
20208 case UROWID:
20209 case VARRAY:
20210 case VARYING:
20211 case BFILE:
20212 case BLOB:
20213 case CLOB:
20214 case NCLOB:
20215 case YEAR:
20216 case LOCAL:
20217 case ZONE:
20218 case CHARACTER:
20219 case AFTER:
20220 case BEFORE:
20221 case OLD:
20222 case PARENT:
20223 case ANALYZE:
20224 case ASSOCIATE:
20225 case AUDIT:
20226 case COMPOUND:
20227 case DATABASE:
20228 case CALL:
20229 case DDL:
20230 case DISASSOCIATE:
20231 case EACH:
20232 case FOLLOWS:
20233 case LOGOFF:
20234 case LOGON:
20235 case NESTED:
20236 case NOAUDIT:
20237 case SCHEMA:
20238 case SERVERERROR:
20239 case SHUTDOWN:
20240 case STARTUP:
20241 case STATEMENT:
20242 case STATISTICS:
20243 case SUSPEND:
20244 case TRUNCATE:
20245 case WRAPPED:
20246 case LIBRARY:
20247 case NAME:
20248 case STRUCT:
20249 case CONTEXT:
20250 case PARAMETERS:
20251 case LENGTH:
20252 case TDO:
20253 case MAXLEN:
20254 case CHARSETID:
20255 case CHARSETFORM:
20256 case ACCEPT:
20257 case ACCESSIBLE:
20258 case COPY:
20259 case DEFINE:
20260 case DISCONNECT:
20261 case HOST:
20262 case PRINT:
20263 case QUIT:
20264 case REMARK:
20265 case UNDEFINE:
20266 case VARIABLE:
20267 case WHENEVER:
20268 case ATTACH:
20269 case CAST:
20270 case TREAT:
20271 case TRIM:
20272 case LEFT:
20273 case RIGHT:
20274 case BOTH:
20275 case EMPTY:
20276 case MULTISET:
20277 case SUBMULTISET:
20278 case LEADING:
20279 case TRAILING:
20280 case CHAR_CS:
20281 case NCHAR_CS:
20282 case DBTIMEZONE:
20283 case SESSIONTIMEZONE:
20284 case AUTHENTICATED:
20285 case LINK:
20286 case SHARED:
20287 case DIRECTORY:
20288 case USER:
20289 case IDENTIFIER:
20290 case QUOTED_LITERAL:
20291 simpleNode = Name();
20292 sb.append(simpleNode.getImage()) ;
20293 break;
20294 default:
20295 jj_la1[266] = jj_gen;
20296 if (jj_2_54(2147483647)) {
20297 jj_consume_token(SELECT);
20298 sb.append("SELECT ...");
20299 Skip2NextTerminator(null,";");
20300 } else if (jj_2_55(2147483647)) {
20301 jj_consume_token(5);
20302 sb.append("(SELECT ...");
20303 Skip2NextTerminator("(",")");
20304 jj_consume_token(7);
20305 } else if (jj_2_56(2147483647)) {
20306 jj_consume_token(WITH);
20307 sb.append("WITH ...");
20308 Skip2NextTerminator(null,";");
20309 } else if (jj_2_57(2147483647)) {
20310 jj_consume_token(5);
20311 sb.append("(WITH ...");
20312 Skip2NextTerminator("(",")");
20313 jj_consume_token(7);
20314 } else {
20315 switch (jj_nt.kind) {
20316 case 5:
20317 jj_consume_token(5);
20318 sb.append("(");
20319 simpleNode = Expression();
20320 sb.append(simpleNode.getImage());
20321 label_63:
20322 while (true) {
20323 switch (jj_nt.kind) {
20324 case 6:
20325 ;
20326 break;
20327 default:
20328 jj_la1[264] = jj_gen;
20329 break label_63;
20330 }
20331 jj_consume_token(6);
20332 sb.append(", ");
20333 simpleNode = Expression();
20334 sb.append(simpleNode.getImage());
20335 }
20336 jj_consume_token(7);
20337 sb.append(")");
20338 break;
20339 default:
20340 jj_la1[267] = jj_gen;
20341 jj_consume_token(-1);
20342 throw new ParseException();
20343 }
20344 }
20345 }
20346 }
20347 }
20348 jjtree.closeNodeScope(jjtn000, true);
20349 jjtc000 = false;
20350 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20351 } catch (Throwable jjte000) {
20352 if (jjtc000) {
20353 jjtree.clearNodeScope(jjtn000);
20354 jjtc000 = false;
20355 } else {
20356 jjtree.popNode();
20357 }
20358 if (jjte000 instanceof RuntimeException) {
20359 {if (true) throw (RuntimeException)jjte000;}
20360 }
20361 if (jjte000 instanceof ParseException) {
20362 {if (true) throw (ParseException)jjte000;}
20363 }
20364 {if (true) throw (Error)jjte000;}
20365 } finally {
20366 if (jjtc000) {
20367 jjtree.closeNodeScope(jjtn000, true);
20368 }
20369 }
20370 throw new Error("Missing return statement in function");
20371 }
20372
20373 final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
20374
20375 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
20376 boolean jjtc000 = true;
20377 jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
20378 try {
20379 switch (jj_nt.kind) {
20380 case 3:
20381 jj_consume_token(3);
20382 sb.append(".");
20383 suffixNode = QualifiedID();
20384 sb.append(suffixNode.toString()) ;
20385 break;
20386 case 2:
20387 jj_consume_token(2);
20388 sb.append("@");
20389 suffixNode = QualifiedID();
20390 sb.append(suffixNode.toString()) ;
20391 break;
20392 case AT:
20393 jj_consume_token(AT);
20394 sb.append(" "); sb.append(token.image.toUpperCase());
20395 switch (jj_nt.kind) {
20396 case LOCAL:
20397 jj_consume_token(LOCAL);
20398 sb.append(" "); sb.append(token.image.toUpperCase());
20399 break;
20400 case TIME:
20401 jj_consume_token(TIME);
20402 jj_consume_token(ZONE);
20403 sb.append(" TIME ZONE");
20404 switch (jj_nt.kind) {
20405 case DBTIMEZONE:
20406 jj_consume_token(DBTIMEZONE);
20407 sb.append(" "); sb.append(token.image.toUpperCase());
20408 break;
20409 case SESSIONTIMEZONE:
20410 jj_consume_token(SESSIONTIMEZONE);
20411 sb.append(" "); sb.append(token.image.toUpperCase());
20412 break;
20413 case STRING_LITERAL:
20414 suffixNode = StringLiteral();
20415 sb.append(" "); sb.append(suffixNode.toString());
20416 break;
20417 case 5:
20418 case 16:
20419 case 17:
20420 case REPLACE:
20421 case DEFINER:
20422 case CURRENT_USER:
20423 case LANGUAGE:
20424 case INLINE:
20425 case ADD:
20426 case AGGREGATE:
20427 case ARRAY:
20428 case AT:
20429 case ATTRIBUTE:
20430 case AUTHID:
20431 case BODY:
20432 case BULK:
20433 case BYTE:
20434 case CASCADE:
20435 case CASE:
20436 case CLOSE:
20437 case COALESCE:
20438 case COLLECT:
20439 case COLUMN:
20440 case COMMENT:
20441 case COMMIT:
20442 case CONSTRUCTOR:
20443 case CONTINUE:
20444 case CONVERT:
20445 case CURRENT:
20446 case CURSOR:
20447 case DATA:
20448 case DATE:
20449 case DAY:
20450 case DISABLE:
20451 case EDITIONABLE:
20452 case ELEMENT:
20453 case ENABLE:
20454 case ESCAPE:
20455 case EXCEPT:
20456 case EXCEPTIONS:
20457 case EXIT:
20458 case EXTERNAL:
20459 case EXTENDS:
20460 case EXTRACT:
20461 case FALSE:
20462 case FINAL:
20463 case FORCE:
20464 case FUNCTION:
20465 case GLOBAL:
20466 case HASH:
20467 case HEAP:
20468 case HOUR:
20469 case IMMEDIATE:
20470 case INDICES:
20471 case INDEXTYPE:
20472 case INDICATOR:
20473 case INSTANTIABLE:
20474 case INTERVAL:
20475 case INVALIDATE:
20476 case ISOLATION:
20477 case JAVA:
20478 case LEVEL:
20479 case LIMIT:
20480 case LOOP:
20481 case MAP:
20482 case MAX:
20483 case MEMBER:
20484 case MERGE:
20485 case MIN:
20486 case MINUTE:
20487 case MLSLABEL:
20488 case MODIFY:
20489 case MOD:
20490 case MONTH:
20491 case NATURAL:
20492 case NEW:
20493 case NEW_DOT:
20494 case NO:
20495 case NONEDITIONABLE:
20496 case NOT:
20497 case NULL:
20498 case NULLIF:
20499 case OBJECT:
20500 case OID:
20501 case OPAQUE:
20502 case OPEN:
20503 case OPERATOR:
20504 case ORGANIZATION:
20505 case OTHERS:
20506 case OVERRIDING:
20507 case PACKAGE:
20508 case PARTITION:
20509 case PRESERVE:
20510 case PRIVATE:
20511 case PROCEDURE:
20512 case RANGE:
20513 case RAW:
20514 case REAL:
20515 case RECORD:
20516 case REF:
20517 case RELEASE:
20518 case RELIES_ON:
20519 case RENAME:
20520 case RESULT:
20521 case RETURN:
20522 case RETURNING:
20523 case REVERSE:
20524 case ROLLBACK:
20525 case ROW:
20526 case ROWS:
20527 case ROWID:
20528 case ROWNUM:
20529 case SAVE:
20530 case SAVEPOINT:
20531 case SECOND:
20532 case SELECT:
20533 case SELF:
20534 case SET:
20535 case SPACE:
20536 case SQL:
20537 case SQLCODE:
20538 case SQLERRM:
20539 case STATIC:
20540 case SUBTYPE:
20541 case SUBSTITUTABLE:
20542 case SUCCESSFUL:
20543 case SYSDATE:
20544 case SYS_REFCURSOR:
20545 case TEMPORARY:
20546 case TIME:
20547 case TIMESTAMP:
20548 case TIMEZONE_REGION:
20549 case TIMEZONE_ABBR:
20550 case TIMEZONE_MINUTE:
20551 case TIMEZONE_HOUR:
20552 case TRANSACTION:
20553 case TRUE:
20554 case TYPE:
20555 case UNDER:
20556 case USING:
20557 case YES:
20558 case SHOW:
20559 case A:
20560 case DOUBLE:
20561 case DEC:
20562 case PRECISION:
20563 case INT:
20564 case NUMERIC:
20565 case NCHAR:
20566 case NVARCHAR2:
20567 case STRING:
20568 case UROWID:
20569 case VARRAY:
20570 case VARYING:
20571 case BFILE:
20572 case BLOB:
20573 case CLOB:
20574 case NCLOB:
20575 case YEAR:
20576 case LOCAL:
20577 case WITH:
20578 case ZONE:
20579 case CHARACTER:
20580 case AFTER:
20581 case BEFORE:
20582 case OLD:
20583 case PARENT:
20584 case CC_IF:
20585 case ANALYZE:
20586 case ASSOCIATE:
20587 case AUDIT:
20588 case COMPOUND:
20589 case DATABASE:
20590 case CALL:
20591 case DDL:
20592 case DISASSOCIATE:
20593 case EACH:
20594 case FOLLOWS:
20595 case LOGOFF:
20596 case LOGON:
20597 case NESTED:
20598 case NOAUDIT:
20599 case SCHEMA:
20600 case SERVERERROR:
20601 case SHUTDOWN:
20602 case STARTUP:
20603 case STATEMENT:
20604 case STATISTICS:
20605 case SUSPEND:
20606 case TRUNCATE:
20607 case WRAPPED:
20608 case LIBRARY:
20609 case NAME:
20610 case STRUCT:
20611 case CONTEXT:
20612 case PARAMETERS:
20613 case LENGTH:
20614 case TDO:
20615 case MAXLEN:
20616 case CHARSETID:
20617 case CHARSETFORM:
20618 case ACCEPT:
20619 case ACCESSIBLE:
20620 case COPY:
20621 case DEFINE:
20622 case DISCONNECT:
20623 case HOST:
20624 case PRINT:
20625 case QUIT:
20626 case REMARK:
20627 case UNDEFINE:
20628 case VARIABLE:
20629 case WHENEVER:
20630 case ATTACH:
20631 case CAST:
20632 case TREAT:
20633 case TRIM:
20634 case LEFT:
20635 case RIGHT:
20636 case BOTH:
20637 case EMPTY:
20638 case MULTISET:
20639 case SUBMULTISET:
20640 case LEADING:
20641 case TRAILING:
20642 case CHAR_CS:
20643 case NCHAR_CS:
20644 case AUTHENTICATED:
20645 case LINK:
20646 case SHARED:
20647 case DIRECTORY:
20648 case USER:
20649 case IDENTIFIER:
20650 case UNSIGNED_NUMERIC_LITERAL:
20651 case CHARACTER_LITERAL:
20652 case QUOTED_LITERAL:
20653 suffixNode = Expression();
20654 sb.append(" "); sb.append(suffixNode.toString());
20655 break;
20656 default:
20657 jj_la1[268] = jj_gen;
20658 jj_consume_token(-1);
20659 throw new ParseException();
20660 }
20661 break;
20662 default:
20663 jj_la1[269] = jj_gen;
20664 jj_consume_token(-1);
20665 throw new ParseException();
20666 }
20667 break;
20668 case 5:
20669 arguments = Arguments();
20670 sb.append(arguments) ;
20671 break;
20672 default:
20673 jj_la1[270] = jj_gen;
20674 jj_consume_token(-1);
20675 throw new ParseException();
20676 }
20677 jjtree.closeNodeScope(jjtn000, true);
20678 jjtc000 = false;
20679 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20680 } catch (Throwable jjte000) {
20681 if (jjtc000) {
20682 jjtree.clearNodeScope(jjtn000);
20683 jjtc000 = false;
20684 } else {
20685 jjtree.popNode();
20686 }
20687 if (jjte000 instanceof RuntimeException) {
20688 {if (true) throw (RuntimeException)jjte000;}
20689 }
20690 if (jjte000 instanceof ParseException) {
20691 {if (true) throw (ParseException)jjte000;}
20692 }
20693 {if (true) throw (Error)jjte000;}
20694 } finally {
20695 if (jjtc000) {
20696 jjtree.closeNodeScope(jjtn000, true);
20697 }
20698 }
20699 throw new Error("Missing return statement in function");
20700 }
20701
20702 final public ASTLiteral Literal() throws ParseException {
20703
20704 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20705 boolean jjtc000 = true;
20706 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20707 Token t = null ;
20708 try {
20709 switch (jj_nt.kind) {
20710 case UNSIGNED_NUMERIC_LITERAL:
20711 simpleNode = NumericLiteral();
20712 break;
20713 case CHARACTER_LITERAL:
20714 t = jj_consume_token(CHARACTER_LITERAL);
20715 break;
20716 case STRING_LITERAL:
20717
20718 simpleNode = StringLiteral();
20719 break;
20720 case FALSE:
20721 case TRUE:
20722 simpleNode = BooleanLiteral();
20723 break;
20724 case NULL:
20725 simpleNode = NullLiteral();
20726 break;
20727 case DATE:
20728 case INTERVAL:
20729 case TIMESTAMP:
20730 simpleNode = DateTimeLiteral();
20731 break;
20732 default:
20733 jj_la1[271] = jj_gen;
20734 jj_consume_token(-1);
20735 throw new ParseException();
20736 }
20737 jjtree.closeNodeScope(jjtn000, true);
20738 jjtc000 = false;
20739 if (null != simpleNode)
20740 {
20741 jjtn000.setImage( simpleNode.getImage() ) ;
20742 }
20743 else if (null != t)
20744 {
20745 jjtn000.setImage( t.image ) ;
20746 }
20747 {if (true) return jjtn000 ;}
20748 } catch (Throwable jjte000) {
20749 if (jjtc000) {
20750 jjtree.clearNodeScope(jjtn000);
20751 jjtc000 = false;
20752 } else {
20753 jjtree.popNode();
20754 }
20755 if (jjte000 instanceof RuntimeException) {
20756 {if (true) throw (RuntimeException)jjte000;}
20757 }
20758 if (jjte000 instanceof ParseException) {
20759 {if (true) throw (ParseException)jjte000;}
20760 }
20761 {if (true) throw (Error)jjte000;}
20762 } finally {
20763 if (jjtc000) {
20764 jjtree.closeNodeScope(jjtn000, true);
20765 }
20766 }
20767 throw new Error("Missing return statement in function");
20768 }
20769
20770 final public ASTStringLiteral StringLiteral() throws ParseException {
20771
20772 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20773 boolean jjtc000 = true;
20774 jjtree.openNodeScope(jjtn000);Token thisToken = null;
20775 StringBuilder literal = new StringBuilder() ;
20776 char startDelimiter ;
20777 char endDelimiter ;
20778 String terminator = null;
20779 try {
20780 thisToken = jj_consume_token(STRING_LITERAL);
20781 literal.append(thisToken.image);
20782
20783
20784
20785
20786
20787 if (thisToken.image.toUpperCase().startsWith("Q'")
20788 && thisToken.image.length() > 2
20789 )
20790 {
20791
20792
20793 startDelimiter= thisToken.image.charAt(2) ;
20794
20795
20796
20797
20798 switch (startDelimiter)
20799 {
20800 case '<' : endDelimiter = '>' ; break ;
20801 case '{' : endDelimiter = '}' ; break ;
20802 case '(' : endDelimiter = ')' ; break ;
20803 case '[' : endDelimiter = ']' ; break ;
20804 default: endDelimiter = startDelimiter ;
20805 }
20806
20807 terminator = new String(endDelimiter + "'");
20808 if (!thisToken.image.endsWith(terminator))
20809 {
20810
20811 literal.append(ReadPastNextOccurrence(terminator));
20812 }
20813 }
20814 jjtree.closeNodeScope(jjtn000, true);
20815 jjtc000 = false;
20816 jjtn000.setImage(literal.toString()) ; jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20817 } finally {
20818 if (jjtc000) {
20819 jjtree.closeNodeScope(jjtn000, true);
20820 }
20821 }
20822 throw new Error("Missing return statement in function");
20823 }
20824
20825 final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20826
20827 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20828 boolean jjtc000 = true;
20829 jjtree.openNodeScope(jjtn000);
20830 try {
20831 switch (jj_nt.kind) {
20832 case TRUE:
20833 jj_consume_token(TRUE);
20834 break;
20835 case FALSE:
20836 jj_consume_token(FALSE);
20837 break;
20838 default:
20839 jj_la1[272] = jj_gen;
20840 jj_consume_token(-1);
20841 throw new ParseException();
20842 }
20843 jjtree.closeNodeScope(jjtn000, true);
20844 jjtc000 = false;
20845 jjtn000.setImage(token.image) ;
20846 {if (true) return jjtn000;}
20847 } finally {
20848 if (jjtc000) {
20849 jjtree.closeNodeScope(jjtn000, true);
20850 }
20851 }
20852 throw new Error("Missing return statement in function");
20853 }
20854
20855 final public ASTNullLiteral NullLiteral() throws ParseException {
20856
20857 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20858 boolean jjtc000 = true;
20859 jjtree.openNodeScope(jjtn000);
20860 try {
20861 jj_consume_token(NULL);
20862 jjtree.closeNodeScope(jjtn000, true);
20863 jjtc000 = false;
20864 jjtn000.setImage(token.image) ;
20865 {if (true) return jjtn000 ;}
20866 } finally {
20867 if (jjtc000) {
20868 jjtree.closeNodeScope(jjtn000, true);
20869 }
20870 }
20871 throw new Error("Missing return statement in function");
20872 }
20873
20874 final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20875
20876 ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20877 boolean jjtc000 = true;
20878 jjtree.openNodeScope(jjtn000);
20879 try {
20880 switch (jj_nt.kind) {
20881 case A:
20882 jj_consume_token(A);
20883 jj_consume_token(SET);
20884 break;
20885 case EMPTY:
20886 jj_consume_token(EMPTY);
20887 break;
20888 default:
20889 jj_la1[273] = jj_gen;
20890 jj_consume_token(-1);
20891 throw new ParseException();
20892 }
20893 jjtree.closeNodeScope(jjtn000, true);
20894 jjtc000 = false;
20895 {if (true) return jjtn000;}
20896 } finally {
20897 if (jjtc000) {
20898 jjtree.closeNodeScope(jjtn000, true);
20899 }
20900 }
20901 throw new Error("Missing return statement in function");
20902 }
20903
20904
20905
20906
20907
20908
20909 final public ASTNumericLiteral NumericLiteral() throws ParseException {
20910
20911 ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20912 boolean jjtc000 = true;
20913 jjtree.openNodeScope(jjtn000);Token t = null ;
20914 try {
20915
20916 t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20917 jjtree.closeNodeScope(jjtn000, true);
20918 jjtc000 = false;
20919 jjtn000.setImage(t.image) ;
20920 {if (true) return jjtn000;}
20921 } finally {
20922 if (jjtc000) {
20923 jjtree.closeNodeScope(jjtn000, true);
20924 }
20925 }
20926 throw new Error("Missing return statement in function");
20927 }
20928
20929
20930
20931 final public ASTLabel Label() throws ParseException {
20932
20933 ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20934 boolean jjtc000 = true;
20935 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20936 try {
20937 jj_consume_token(21);
20938 simpleNode = UnqualifiedID();
20939 jj_consume_token(22);
20940 jjtree.closeNodeScope(jjtn000, true);
20941 jjtc000 = false;
20942 jjtn000.setImage( simpleNode.getImage() ) ;
20943 {if (true) return jjtn000;}
20944 } catch (Throwable jjte000) {
20945 if (jjtc000) {
20946 jjtree.clearNodeScope(jjtn000);
20947 jjtc000 = false;
20948 } else {
20949 jjtree.popNode();
20950 }
20951 if (jjte000 instanceof RuntimeException) {
20952 {if (true) throw (RuntimeException)jjte000;}
20953 }
20954 if (jjte000 instanceof ParseException) {
20955 {if (true) throw (ParseException)jjte000;}
20956 }
20957 {if (true) throw (Error)jjte000;}
20958 } finally {
20959 if (jjtc000) {
20960 jjtree.closeNodeScope(jjtn000, true);
20961 }
20962 }
20963 throw new Error("Missing return statement in function");
20964 }
20965
20966 final public ASTName Name() throws ParseException {
20967
20968 ASTName jjtn000 = new ASTName(this, JJTNAME);
20969 boolean jjtc000 = true;
20970 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20971 StringBuilder sb = new StringBuilder();
20972 try {
20973 simpleNode = UnqualifiedID();
20974 sb.append(simpleNode.getImage()) ;
20975 label_64:
20976 while (true) {
20977 if (jj_2_58(2)) {
20978 ;
20979 } else {
20980 break label_64;
20981 }
20982 switch (jj_nt.kind) {
20983 case 3:
20984 jj_consume_token(3);
20985 sb.append(".") ;
20986 break;
20987 case 11:
20988 jj_consume_token(11);
20989 sb.append("%") ;
20990 break;
20991 default:
20992 jj_la1[274] = jj_gen;
20993 jj_consume_token(-1);
20994 throw new ParseException();
20995 }
20996
20997 simpleNode = QualifiedID();
20998 sb.append(simpleNode.getImage()) ;
20999 }
21000 jjtree.closeNodeScope(jjtn000, true);
21001 jjtc000 = false;
21002 jjtn000.setImage(sb.toString()) ;
21003 {if (true) return jjtn000;}
21004 } catch (Throwable jjte000) {
21005 if (jjtc000) {
21006 jjtree.clearNodeScope(jjtn000);
21007 jjtc000 = false;
21008 } else {
21009 jjtree.popNode();
21010 }
21011 if (jjte000 instanceof RuntimeException) {
21012 {if (true) throw (RuntimeException)jjte000;}
21013 }
21014 if (jjte000 instanceof ParseException) {
21015 {if (true) throw (ParseException)jjte000;}
21016 }
21017 {if (true) throw (Error)jjte000;}
21018 } finally {
21019 if (jjtc000) {
21020 jjtree.closeNodeScope(jjtn000, true);
21021 }
21022 }
21023 throw new Error("Missing return statement in function");
21024 }
21025
21026 final public ASTQualifiedName QualifiedName() throws ParseException {
21027
21028 ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
21029 boolean jjtc000 = true;
21030 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21031 StringBuilder sb = new StringBuilder();
21032 try {
21033 simpleNode = UnqualifiedID();
21034 sb.append(simpleNode.getImage()) ;
21035 label_65:
21036 while (true) {
21037 switch (jj_nt.kind) {
21038 case 3:
21039 ;
21040 break;
21041 default:
21042 jj_la1[275] = jj_gen;
21043 break label_65;
21044 }
21045 jj_consume_token(3);
21046 simpleNode = QualifiedID();
21047 sb.append(".") ; sb.append(simpleNode.getImage()) ;
21048 }
21049 jjtree.closeNodeScope(jjtn000, true);
21050 jjtc000 = false;
21051 jjtn000.setImage(sb.toString()) ;
21052 {if (true) return jjtn000 ;}
21053 } catch (Throwable jjte000) {
21054 if (jjtc000) {
21055 jjtree.clearNodeScope(jjtn000);
21056 jjtc000 = false;
21057 } else {
21058 jjtree.popNode();
21059 }
21060 if (jjte000 instanceof RuntimeException) {
21061 {if (true) throw (RuntimeException)jjte000;}
21062 }
21063 if (jjte000 instanceof ParseException) {
21064 {if (true) throw (ParseException)jjte000;}
21065 }
21066 {if (true) throw (Error)jjte000;}
21067 } finally {
21068 if (jjtc000) {
21069 jjtree.closeNodeScope(jjtn000, true);
21070 }
21071 }
21072 throw new Error("Missing return statement in function");
21073 }
21074
21075 final public ASTArguments Arguments() throws ParseException {
21076
21077 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
21078 boolean jjtc000 = true;
21079 jjtree.openNodeScope(jjtn000);
21080 try {
21081 jj_consume_token(5);
21082 switch (jj_nt.kind) {
21083 case 5:
21084 case 16:
21085 case 17:
21086 case REPLACE:
21087 case DEFINER:
21088 case CURRENT_USER:
21089 case LANGUAGE:
21090 case INLINE:
21091 case ADD:
21092 case AGGREGATE:
21093 case ARRAY:
21094 case AT:
21095 case ATTRIBUTE:
21096 case AUTHID:
21097 case BODY:
21098 case BULK:
21099 case BYTE:
21100 case CASCADE:
21101 case CASE:
21102 case CLOSE:
21103 case COALESCE:
21104 case COLLECT:
21105 case COLUMN:
21106 case COMMENT:
21107 case COMMIT:
21108 case CONSTRUCTOR:
21109 case CONTINUE:
21110 case CONVERT:
21111 case CURRENT:
21112 case CURSOR:
21113 case DATA:
21114 case DATE:
21115 case DAY:
21116 case DISABLE:
21117 case EDITIONABLE:
21118 case ELEMENT:
21119 case ENABLE:
21120 case ESCAPE:
21121 case EXCEPT:
21122 case EXCEPTIONS:
21123 case EXIT:
21124 case EXTERNAL:
21125 case EXTENDS:
21126 case EXTRACT:
21127 case FALSE:
21128 case FINAL:
21129 case FORCE:
21130 case FUNCTION:
21131 case GLOBAL:
21132 case HASH:
21133 case HEAP:
21134 case HOUR:
21135 case IMMEDIATE:
21136 case INDICES:
21137 case INDEXTYPE:
21138 case INDICATOR:
21139 case INSTANTIABLE:
21140 case INTERVAL:
21141 case INVALIDATE:
21142 case ISOLATION:
21143 case JAVA:
21144 case LEVEL:
21145 case LIMIT:
21146 case LOOP:
21147 case MAP:
21148 case MAX:
21149 case MEMBER:
21150 case MERGE:
21151 case MIN:
21152 case MINUTE:
21153 case MLSLABEL:
21154 case MODIFY:
21155 case MOD:
21156 case MONTH:
21157 case NATURAL:
21158 case NEW:
21159 case NEW_DOT:
21160 case NO:
21161 case NONEDITIONABLE:
21162 case NOT:
21163 case NULL:
21164 case NULLIF:
21165 case OBJECT:
21166 case OID:
21167 case OPAQUE:
21168 case OPEN:
21169 case OPERATOR:
21170 case ORGANIZATION:
21171 case OTHERS:
21172 case OVERRIDING:
21173 case PACKAGE:
21174 case PARTITION:
21175 case PRESERVE:
21176 case PRIVATE:
21177 case PROCEDURE:
21178 case RANGE:
21179 case RAW:
21180 case REAL:
21181 case RECORD:
21182 case REF:
21183 case RELEASE:
21184 case RELIES_ON:
21185 case RENAME:
21186 case RESULT:
21187 case RETURN:
21188 case RETURNING:
21189 case REVERSE:
21190 case ROLLBACK:
21191 case ROW:
21192 case ROWS:
21193 case ROWID:
21194 case ROWNUM:
21195 case SAVE:
21196 case SAVEPOINT:
21197 case SECOND:
21198 case SELECT:
21199 case SELF:
21200 case SET:
21201 case SPACE:
21202 case SQL:
21203 case SQLCODE:
21204 case SQLERRM:
21205 case STATIC:
21206 case SUBTYPE:
21207 case SUBSTITUTABLE:
21208 case SUCCESSFUL:
21209 case SYSDATE:
21210 case SYS_REFCURSOR:
21211 case TEMPORARY:
21212 case TIME:
21213 case TIMESTAMP:
21214 case TIMEZONE_REGION:
21215 case TIMEZONE_ABBR:
21216 case TIMEZONE_MINUTE:
21217 case TIMEZONE_HOUR:
21218 case TRANSACTION:
21219 case TRUE:
21220 case TYPE:
21221 case UNDER:
21222 case USING:
21223 case YES:
21224 case SHOW:
21225 case A:
21226 case DOUBLE:
21227 case DEC:
21228 case PRECISION:
21229 case INT:
21230 case NUMERIC:
21231 case NCHAR:
21232 case NVARCHAR2:
21233 case STRING:
21234 case UROWID:
21235 case VARRAY:
21236 case VARYING:
21237 case BFILE:
21238 case BLOB:
21239 case CLOB:
21240 case NCLOB:
21241 case YEAR:
21242 case LOCAL:
21243 case WITH:
21244 case ZONE:
21245 case CHARACTER:
21246 case AFTER:
21247 case BEFORE:
21248 case OLD:
21249 case PARENT:
21250 case CC_IF:
21251 case ANALYZE:
21252 case ASSOCIATE:
21253 case AUDIT:
21254 case COMPOUND:
21255 case DATABASE:
21256 case CALL:
21257 case DDL:
21258 case DISASSOCIATE:
21259 case EACH:
21260 case FOLLOWS:
21261 case LOGOFF:
21262 case LOGON:
21263 case NESTED:
21264 case NOAUDIT:
21265 case SCHEMA:
21266 case SERVERERROR:
21267 case SHUTDOWN:
21268 case STARTUP:
21269 case STATEMENT:
21270 case STATISTICS:
21271 case SUSPEND:
21272 case TRUNCATE:
21273 case WRAPPED:
21274 case LIBRARY:
21275 case NAME:
21276 case STRUCT:
21277 case CONTEXT:
21278 case PARAMETERS:
21279 case LENGTH:
21280 case TDO:
21281 case MAXLEN:
21282 case CHARSETID:
21283 case CHARSETFORM:
21284 case ACCEPT:
21285 case ACCESSIBLE:
21286 case COPY:
21287 case DEFINE:
21288 case DISCONNECT:
21289 case HOST:
21290 case PRINT:
21291 case QUIT:
21292 case REMARK:
21293 case UNDEFINE:
21294 case VARIABLE:
21295 case WHENEVER:
21296 case ATTACH:
21297 case CAST:
21298 case TREAT:
21299 case TRIM:
21300 case LEFT:
21301 case RIGHT:
21302 case BOTH:
21303 case EMPTY:
21304 case MULTISET:
21305 case SUBMULTISET:
21306 case LEADING:
21307 case TRAILING:
21308 case CHAR_CS:
21309 case NCHAR_CS:
21310 case DBTIMEZONE:
21311 case SESSIONTIMEZONE:
21312 case AUTHENTICATED:
21313 case LINK:
21314 case SHARED:
21315 case DIRECTORY:
21316 case USER:
21317 case IDENTIFIER:
21318 case UNSIGNED_NUMERIC_LITERAL:
21319 case CHARACTER_LITERAL:
21320 case STRING_LITERAL:
21321 case QUOTED_LITERAL:
21322 ArgumentList();
21323 break;
21324 default:
21325 jj_la1[276] = jj_gen;
21326 ;
21327 }
21328 jj_consume_token(7);
21329 jjtree.closeNodeScope(jjtn000, true);
21330 jjtc000 = false;
21331 {if (true) return jjtn000 ;}
21332 } catch (Throwable jjte000) {
21333 if (jjtc000) {
21334 jjtree.clearNodeScope(jjtn000);
21335 jjtc000 = false;
21336 } else {
21337 jjtree.popNode();
21338 }
21339 if (jjte000 instanceof RuntimeException) {
21340 {if (true) throw (RuntimeException)jjte000;}
21341 }
21342 if (jjte000 instanceof ParseException) {
21343 {if (true) throw (ParseException)jjte000;}
21344 }
21345 {if (true) throw (Error)jjte000;}
21346 } finally {
21347 if (jjtc000) {
21348 jjtree.closeNodeScope(jjtn000, true);
21349 }
21350 }
21351 throw new Error("Missing return statement in function");
21352 }
21353
21354 final public ASTArgumentList ArgumentList() throws ParseException {
21355
21356 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
21357 boolean jjtc000 = true;
21358 jjtree.openNodeScope(jjtn000);
21359 try {
21360 Argument();
21361 label_66:
21362 while (true) {
21363 switch (jj_nt.kind) {
21364 case 6:
21365 ;
21366 break;
21367 default:
21368 jj_la1[277] = jj_gen;
21369 break label_66;
21370 }
21371 jj_consume_token(6);
21372 Argument();
21373 }
21374 jjtree.closeNodeScope(jjtn000, true);
21375 jjtc000 = false;
21376 {if (true) return jjtn000 ;}
21377 } catch (Throwable jjte000) {
21378 if (jjtc000) {
21379 jjtree.clearNodeScope(jjtn000);
21380 jjtc000 = false;
21381 } else {
21382 jjtree.popNode();
21383 }
21384 if (jjte000 instanceof RuntimeException) {
21385 {if (true) throw (RuntimeException)jjte000;}
21386 }
21387 if (jjte000 instanceof ParseException) {
21388 {if (true) throw (ParseException)jjte000;}
21389 }
21390 {if (true) throw (Error)jjte000;}
21391 } finally {
21392 if (jjtc000) {
21393 jjtree.closeNodeScope(jjtn000, true);
21394 }
21395 }
21396 throw new Error("Missing return statement in function");
21397 }
21398
21399 final public ASTArgument Argument() throws ParseException {
21400
21401 ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
21402 boolean jjtc000 = true;
21403 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21404 try {
21405 if (jj_2_59(2)) {
21406 simpleNode = UnqualifiedID();
21407 switch (jj_nt.kind) {
21408 case 23:
21409 jj_consume_token(23);
21410 break;
21411 case AS:
21412 jj_consume_token(AS);
21413 break;
21414 default:
21415 jj_la1[278] = jj_gen;
21416 jj_consume_token(-1);
21417 throw new ParseException();
21418 }
21419 } else {
21420 ;
21421 }
21422 Expression();
21423 switch (jj_nt.kind) {
21424 case USING:
21425 jj_consume_token(USING);
21426 switch (jj_nt.kind) {
21427 case CHAR_CS:
21428 jj_consume_token(CHAR_CS);
21429 break;
21430 case NCHAR_CS:
21431 jj_consume_token(NCHAR_CS);
21432 break;
21433 default:
21434 jj_la1[279] = jj_gen;
21435 jj_consume_token(-1);
21436 throw new ParseException();
21437 }
21438 break;
21439 default:
21440 jj_la1[280] = jj_gen;
21441 ;
21442 }
21443 jjtree.closeNodeScope(jjtn000, true);
21444 jjtc000 = false;
21445 if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
21446 {if (true) return jjtn000 ;}
21447 } catch (Throwable jjte000) {
21448 if (jjtc000) {
21449 jjtree.clearNodeScope(jjtn000);
21450 jjtc000 = false;
21451 } else {
21452 jjtree.popNode();
21453 }
21454 if (jjte000 instanceof RuntimeException) {
21455 {if (true) throw (RuntimeException)jjte000;}
21456 }
21457 if (jjte000 instanceof ParseException) {
21458 {if (true) throw (ParseException)jjte000;}
21459 }
21460 {if (true) throw (Error)jjte000;}
21461 } finally {
21462 if (jjtc000) {
21463 jjtree.closeNodeScope(jjtn000, true);
21464 }
21465 }
21466 throw new Error("Missing return statement in function");
21467 }
21468
21469
21470
21471
21472 final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
21473
21474 ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
21475 boolean jjtc000 = true;
21476 jjtree.openNodeScope(jjtn000);
21477 try {
21478 VariableOrConstantDeclarator();
21479 jj_consume_token(4);
21480 jjtree.closeNodeScope(jjtn000, true);
21481 jjtc000 = false;
21482 {if (true) return jjtn000 ;}
21483 } catch (Throwable jjte000) {
21484 if (jjtc000) {
21485 jjtree.clearNodeScope(jjtn000);
21486 jjtc000 = false;
21487 } else {
21488 jjtree.popNode();
21489 }
21490 if (jjte000 instanceof RuntimeException) {
21491 {if (true) throw (RuntimeException)jjte000;}
21492 }
21493 if (jjte000 instanceof ParseException) {
21494 {if (true) throw (ParseException)jjte000;}
21495 }
21496 {if (true) throw (Error)jjte000;}
21497 } finally {
21498 if (jjtc000) {
21499 jjtree.closeNodeScope(jjtn000, true);
21500 }
21501 }
21502 throw new Error("Missing return statement in function");
21503 }
21504
21505 final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
21506
21507 ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
21508 boolean jjtc000 = true;
21509 jjtree.openNodeScope(jjtn000);Token t ;
21510 try {
21511 t = jj_consume_token(IDENTIFIER);
21512 jjtree.closeNodeScope(jjtn000, true);
21513 jjtc000 = false;
21514 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
21515 } finally {
21516 if (jjtc000) {
21517 jjtree.closeNodeScope(jjtn000, true);
21518 }
21519 }
21520 throw new Error("Missing return statement in function");
21521 }
21522
21523 final public ASTPragma Pragma() throws ParseException {
21524
21525 ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
21526 boolean jjtc000 = true;
21527 jjtree.openNodeScope(jjtn000);
21528 try {
21529 jj_consume_token(PRAGMA);
21530 switch (jj_nt.kind) {
21531 case SERIALLY_REUSABLE:
21532 jj_consume_token(SERIALLY_REUSABLE);
21533 break;
21534 case AUTONOMOUS_TRANSACTION:
21535 jj_consume_token(AUTONOMOUS_TRANSACTION);
21536 break;
21537 case TIMESTAMP:
21538 jj_consume_token(TIMESTAMP);
21539 jj_consume_token(5);
21540 StringLiteral();
21541 jj_consume_token(7);
21542 break;
21543 case RESTRICT_REFERENCES:
21544 jj_consume_token(RESTRICT_REFERENCES);
21545 jj_consume_token(5);
21546 ID();
21547 label_67:
21548 while (true) {
21549 jj_consume_token(6);
21550 switch (jj_nt.kind) {
21551 case REPLACE:
21552 case DEFINER:
21553 case CURRENT_USER:
21554 case SERIALLY_REUSABLE:
21555 case RESTRICT_REFERENCES:
21556 case EXCEPTION_INIT:
21557 case AUTONOMOUS_TRANSACTION:
21558 case LANGUAGE:
21559 case INLINE:
21560 case ADD:
21561 case AGGREGATE:
21562 case ALL:
21563 case ALTER:
21564 case AND:
21565 case ANY:
21566 case ARRAY:
21567 case AS:
21568 case ASC:
21569 case AT:
21570 case ATTRIBUTE:
21571 case AUTHID:
21572 case AVG:
21573 case BETWEEN:
21574 case BINARY_INTEGER:
21575 case BODY:
21576 case BOOLEAN:
21577 case BULK:
21578 case BY:
21579 case BYTE:
21580 case CASCADE:
21581 case CASE:
21582 case CHAR:
21583 case CHAR_BASE:
21584 case CHECK:
21585 case CLOSE:
21586 case CLUSTER:
21587 case COALESCE:
21588 case COLLECT:
21589 case COLUMN:
21590 case COMMENT:
21591 case COMMIT:
21592 case COMPRESS:
21593 case CONNECT:
21594 case CONSTANT:
21595 case CONSTRUCTOR:
21596 case CONTINUE:
21597 case CONVERT:
21598 case CREATE:
21599 case CURRENT:
21600 case CURRVAL:
21601 case CURSOR:
21602 case DATA:
21603 case DATE:
21604 case DAY:
21605 case DECLARE:
21606 case DECIMAL:
21607 case _DEFAULT:
21608 case DELETE:
21609 case DESC:
21610 case DISABLE:
21611 case DISTINCT:
21612 case DO:
21613 case DROP:
21614 case EDITIONABLE:
21615 case ELEMENT:
21616 case ELSE:
21617 case ELSIF:
21618 case ENABLE:
21619 case ESCAPE:
21620 case EXCEPT:
21621 case EXCEPTION:
21622 case EXCEPTIONS:
21623 case EXCLUSIVE:
21624 case EXECUTE:
21625 case EXISTS:
21626 case EXIT:
21627 case EXTERNAL:
21628 case EXTENDS:
21629 case EXTRACT:
21630 case FALSE:
21631 case FETCH:
21632 case FINAL:
21633 case FLOAT:
21634 case FOR:
21635 case FORALL:
21636 case FORCE:
21637 case FROM:
21638 case FUNCTION:
21639 case GLOBAL:
21640 case GOTO:
21641 case GROUP:
21642 case HASH:
21643 case HAVING:
21644 case HEAP:
21645 case HOUR:
21646 case IF:
21647 case IMMEDIATE:
21648 case IN:
21649 case INDEX:
21650 case INDICES:
21651 case INDEXTYPE:
21652 case INDICATOR:
21653 case INSERT:
21654 case INSTANTIABLE:
21655 case INTEGER:
21656 case INTERFACE:
21657 case INTERSECT:
21658 case INTERVAL:
21659 case INTO:
21660 case INVALIDATE:
21661 case IS:
21662 case ISOLATION:
21663 case JAVA:
21664 case LEVEL:
21665 case LIKE:
21666 case LIMIT:
21667 case LIMITED:
21668 case LOCK:
21669 case LONG:
21670 case LOOP:
21671 case MAP:
21672 case MAX:
21673 case MEMBER:
21674 case MERGE:
21675 case MIN:
21676 case MINUS:
21677 case MINUTE:
21678 case MLSLABEL:
21679 case MODIFY:
21680 case MOD:
21681 case MODE:
21682 case MONTH:
21683 case NATURAL:
21684 case NATURALN:
21685 case NEW:
21686 case NEXTVAL:
21687 case NO:
21688 case NOCOPY:
21689 case NONEDITIONABLE:
21690 case NOT:
21691 case NOWAIT:
21692 case NULL:
21693 case NULLIF:
21694 case NUMBER:
21695 case BFILE_BASE:
21696 case BLOB_BASE:
21697 case CLOB_BASE:
21698 case DATE_BASE:
21699 case NUMBER_BASE:
21700 case OBJECT:
21701 case OCIROWID:
21702 case OF:
21703 case OID:
21704 case ON:
21705 case OPAQUE:
21706 case OPEN:
21707 case OPERATOR:
21708 case OPTION:
21709 case OR:
21710 case ORDER:
21711 case ORGANIZATION:
21712 case OTHERS:
21713 case OUT:
21714 case OVERRIDING:
21715 case PACKAGE:
21716 case PARTITION:
21717 case PCTFREE:
21718 case PLS_INTEGER:
21719 case POSITIVE:
21720 case POSITIVEN:
21721 case PRESERVE:
21722 case PRIOR:
21723 case PROMPT:
21724 case PRIVATE:
21725 case PROCEDURE:
21726 case PUBLIC:
21727 case RAISE:
21728 case RANGE:
21729 case RAW:
21730 case REAL:
21731 case RECORD:
21732 case REF:
21733 case RELEASE:
21734 case RELIES_ON:
21735 case RENAME:
21736 case RESULT:
21737 case RETURN:
21738 case RETURNING:
21739 case REVERSE:
21740 case ROLLBACK:
21741 case ROW:
21742 case ROWS:
21743 case ROWID:
21744 case ROWNUM:
21745 case ROWTYPE:
21746 case SAVE:
21747 case SAVEPOINT:
21748 case SECOND:
21749 case SELECT:
21750 case SELF:
21751 case SEPARATE:
21752 case SET:
21753 case SHARE:
21754 case SMALLINT:
21755 case SPACE:
21756 case SQL:
21757 case SQLCODE:
21758 case SQLERRM:
21759 case START:
21760 case STATIC:
21761 case STDDEV:
21762 case SUBTYPE:
21763 case SUBSTITUTABLE:
21764 case SUCCESSFUL:
21765 case SUM:
21766 case SYNONYM:
21767 case SYSDATE:
21768 case SYS_REFCURSOR:
21769 case TABLE:
21770 case TEMPORARY:
21771 case THEN:
21772 case TIME:
21773 case TIMESTAMP:
21774 case TIMEZONE_REGION:
21775 case TIMEZONE_ABBR:
21776 case TIMEZONE_MINUTE:
21777 case TIMEZONE_HOUR:
21778 case TO:
21779 case TRANSACTION:
21780 case TRIGGER:
21781 case TRUE:
21782 case TYPE:
21783 case UI:
21784 case UNDER:
21785 case USING:
21786 case WHILE:
21787 case YES:
21788 case SHOW:
21789 case A:
21790 case UPDATE:
21791 case VARCHAR:
21792 case VARCHAR2:
21793 case DOUBLE:
21794 case DEC:
21795 case PRECISION:
21796 case INT:
21797 case NUMERIC:
21798 case SIGNTYPE:
21799 case NCHAR:
21800 case NVARCHAR2:
21801 case STRING:
21802 case UROWID:
21803 case VARRAY:
21804 case VARYING:
21805 case BFILE:
21806 case BLOB:
21807 case CLOB:
21808 case NCLOB:
21809 case YEAR:
21810 case LOCAL:
21811 case WITH:
21812 case ZONE:
21813 case CHARACTER:
21814 case AFTER:
21815 case BEFORE:
21816 case OLD:
21817 case PARENT:
21818 case ANALYZE:
21819 case ASSOCIATE:
21820 case AUDIT:
21821 case COMPOUND:
21822 case DATABASE:
21823 case CALL:
21824 case DDL:
21825 case DISASSOCIATE:
21826 case EACH:
21827 case FOLLOWS:
21828 case LOGOFF:
21829 case LOGON:
21830 case NESTED:
21831 case NOAUDIT:
21832 case SCHEMA:
21833 case SERVERERROR:
21834 case SHUTDOWN:
21835 case STARTUP:
21836 case STATEMENT:
21837 case STATISTICS:
21838 case SUSPEND:
21839 case TRUNCATE:
21840 case WRAPPED:
21841 case LIBRARY:
21842 case NAME:
21843 case STRUCT:
21844 case CONTEXT:
21845 case PARAMETERS:
21846 case LENGTH:
21847 case TDO:
21848 case MAXLEN:
21849 case CHARSETID:
21850 case CHARSETFORM:
21851 case ACCEPT:
21852 case ACCESSIBLE:
21853 case COPY:
21854 case DEFINE:
21855 case DISCONNECT:
21856 case HOST:
21857 case PRINT:
21858 case QUIT:
21859 case REMARK:
21860 case UNDEFINE:
21861 case VARIABLE:
21862 case WHENEVER:
21863 case ATTACH:
21864 case CAST:
21865 case TREAT:
21866 case TRIM:
21867 case LEFT:
21868 case RIGHT:
21869 case BOTH:
21870 case EMPTY:
21871 case MULTISET:
21872 case SUBMULTISET:
21873 case LEADING:
21874 case TRAILING:
21875 case CHAR_CS:
21876 case NCHAR_CS:
21877 case DBTIMEZONE:
21878 case SESSIONTIMEZONE:
21879 case AUTHENTICATED:
21880 case LINK:
21881 case SHARED:
21882 case DIRECTORY:
21883 case USER:
21884 case IDENTIFIER:
21885 case QUOTED_LITERAL:
21886 case SQLDATA_CLASS:
21887 case CUSTOMDATUM_CLASS:
21888 case ORADATA_CLASS:
21889 case JAVA_INTERFACE_CLASS:
21890 ID();
21891 break;
21892 case STRING_LITERAL:
21893 StringLiteral();
21894 break;
21895 default:
21896 jj_la1[281] = jj_gen;
21897 jj_consume_token(-1);
21898 throw new ParseException();
21899 }
21900 switch (jj_nt.kind) {
21901 case 6:
21902 ;
21903 break;
21904 default:
21905 jj_la1[282] = jj_gen;
21906 break label_67;
21907 }
21908 }
21909 jj_consume_token(7);
21910 break;
21911 case EXCEPTION_INIT:
21912 jj_consume_token(EXCEPTION_INIT);
21913 jj_consume_token(5);
21914 jj_consume_token(IDENTIFIER);
21915 jj_consume_token(6);
21916 switch (jj_nt.kind) {
21917 case 16:
21918 case 17:
21919 switch (jj_nt.kind) {
21920 case 16:
21921 jj_consume_token(16);
21922 break;
21923 case 17:
21924 jj_consume_token(17);
21925 break;
21926 default:
21927 jj_la1[283] = jj_gen;
21928 jj_consume_token(-1);
21929 throw new ParseException();
21930 }
21931 break;
21932 default:
21933 jj_la1[284] = jj_gen;
21934 ;
21935 }
21936 NumericLiteral();
21937 jj_consume_token(7);
21938 break;
21939 case INTERFACE:
21940 jj_consume_token(INTERFACE);
21941 jj_consume_token(5);
21942 jj_consume_token(IDENTIFIER);
21943 jj_consume_token(6);
21944 ID();
21945 switch (jj_nt.kind) {
21946 case 6:
21947 jj_consume_token(6);
21948 NumericLiteral();
21949 break;
21950 default:
21951 jj_la1[285] = jj_gen;
21952 ;
21953 }
21954 jj_consume_token(7);
21955 break;
21956 case REPLACE:
21957 case DEFINER:
21958 case CURRENT_USER:
21959 case LANGUAGE:
21960 case INLINE:
21961 case ADD:
21962 case AGGREGATE:
21963 case ARRAY:
21964 case AT:
21965 case ATTRIBUTE:
21966 case AUTHID:
21967 case BODY:
21968 case BULK:
21969 case BYTE:
21970 case CASCADE:
21971 case CLOSE:
21972 case COALESCE:
21973 case COLLECT:
21974 case COLUMN:
21975 case COMMENT:
21976 case COMMIT:
21977 case CONSTRUCTOR:
21978 case CONTINUE:
21979 case CONVERT:
21980 case CURRENT:
21981 case CURSOR:
21982 case DATA:
21983 case DAY:
21984 case DISABLE:
21985 case EDITIONABLE:
21986 case ELEMENT:
21987 case ENABLE:
21988 case ESCAPE:
21989 case EXCEPT:
21990 case EXCEPTIONS:
21991 case EXIT:
21992 case EXTERNAL:
21993 case EXTENDS:
21994 case EXTRACT:
21995 case FALSE:
21996 case FINAL:
21997 case FORCE:
21998 case FUNCTION:
21999 case GLOBAL:
22000 case HASH:
22001 case HEAP:
22002 case HOUR:
22003 case IMMEDIATE:
22004 case INDICES:
22005 case INDEXTYPE:
22006 case INDICATOR:
22007 case INSTANTIABLE:
22008 case INTERVAL:
22009 case INVALIDATE:
22010 case ISOLATION:
22011 case JAVA:
22012 case LEVEL:
22013 case LIMIT:
22014 case LOOP:
22015 case MAP:
22016 case MAX:
22017 case MEMBER:
22018 case MERGE:
22019 case MIN:
22020 case MINUTE:
22021 case MLSLABEL:
22022 case MODIFY:
22023 case MOD:
22024 case MONTH:
22025 case NATURAL:
22026 case NEW:
22027 case NO:
22028 case NONEDITIONABLE:
22029 case NULLIF:
22030 case OBJECT:
22031 case OID:
22032 case OPAQUE:
22033 case OPEN:
22034 case OPERATOR:
22035 case ORGANIZATION:
22036 case OTHERS:
22037 case OVERRIDING:
22038 case PACKAGE:
22039 case PARTITION:
22040 case PRESERVE:
22041 case PRIVATE:
22042 case PROCEDURE:
22043 case RANGE:
22044 case RAW:
22045 case REAL:
22046 case RECORD:
22047 case REF:
22048 case RELEASE:
22049 case RELIES_ON:
22050 case RENAME:
22051 case RESULT:
22052 case RETURN:
22053 case RETURNING:
22054 case REVERSE:
22055 case ROLLBACK:
22056 case ROW:
22057 case ROWS:
22058 case ROWID:
22059 case ROWNUM:
22060 case SAVE:
22061 case SAVEPOINT:
22062 case SECOND:
22063 case SELF:
22064 case SET:
22065 case SPACE:
22066 case SQL:
22067 case SQLCODE:
22068 case SQLERRM:
22069 case STATIC:
22070 case SUBTYPE:
22071 case SUBSTITUTABLE:
22072 case SUCCESSFUL:
22073 case SYSDATE:
22074 case SYS_REFCURSOR:
22075 case TEMPORARY:
22076 case TIME:
22077 case TIMEZONE_REGION:
22078 case TIMEZONE_ABBR:
22079 case TIMEZONE_MINUTE:
22080 case TIMEZONE_HOUR:
22081 case TRANSACTION:
22082 case TRUE:
22083 case TYPE:
22084 case UNDER:
22085 case USING:
22086 case YES:
22087 case SHOW:
22088 case A:
22089 case DOUBLE:
22090 case DEC:
22091 case PRECISION:
22092 case INT:
22093 case NUMERIC:
22094 case NCHAR:
22095 case NVARCHAR2:
22096 case STRING:
22097 case UROWID:
22098 case VARRAY:
22099 case VARYING:
22100 case BFILE:
22101 case BLOB:
22102 case CLOB:
22103 case NCLOB:
22104 case YEAR:
22105 case LOCAL:
22106 case ZONE:
22107 case CHARACTER:
22108 case AFTER:
22109 case BEFORE:
22110 case OLD:
22111 case PARENT:
22112 case ANALYZE:
22113 case ASSOCIATE:
22114 case AUDIT:
22115 case COMPOUND:
22116 case DATABASE:
22117 case CALL:
22118 case DDL:
22119 case DISASSOCIATE:
22120 case EACH:
22121 case FOLLOWS:
22122 case LOGOFF:
22123 case LOGON:
22124 case NESTED:
22125 case NOAUDIT:
22126 case SCHEMA:
22127 case SERVERERROR:
22128 case SHUTDOWN:
22129 case STARTUP:
22130 case STATEMENT:
22131 case STATISTICS:
22132 case SUSPEND:
22133 case TRUNCATE:
22134 case WRAPPED:
22135 case LIBRARY:
22136 case NAME:
22137 case STRUCT:
22138 case CONTEXT:
22139 case PARAMETERS:
22140 case LENGTH:
22141 case TDO:
22142 case MAXLEN:
22143 case CHARSETID:
22144 case CHARSETFORM:
22145 case ACCEPT:
22146 case ACCESSIBLE:
22147 case COPY:
22148 case DEFINE:
22149 case DISCONNECT:
22150 case HOST:
22151 case PRINT:
22152 case QUIT:
22153 case REMARK:
22154 case UNDEFINE:
22155 case VARIABLE:
22156 case WHENEVER:
22157 case ATTACH:
22158 case CAST:
22159 case TREAT:
22160 case TRIM:
22161 case LEFT:
22162 case RIGHT:
22163 case BOTH:
22164 case EMPTY:
22165 case MULTISET:
22166 case SUBMULTISET:
22167 case LEADING:
22168 case TRAILING:
22169 case CHAR_CS:
22170 case NCHAR_CS:
22171 case DBTIMEZONE:
22172 case SESSIONTIMEZONE:
22173 case AUTHENTICATED:
22174 case LINK:
22175 case SHARED:
22176 case DIRECTORY:
22177 case USER:
22178 case IDENTIFIER:
22179 case QUOTED_LITERAL:
22180 QualifiedName();
22181 jj_consume_token(5);
22182 ReadPastNextOccurrence(")");
22183 break;
22184 default:
22185 jj_la1[286] = jj_gen;
22186 jj_consume_token(-1);
22187 throw new ParseException();
22188 }
22189 jj_consume_token(4);
22190 jjtree.closeNodeScope(jjtn000, true);
22191 jjtc000 = false;
22192 {if (true) return jjtn000 ;}
22193 } catch (Throwable jjte000) {
22194 if (jjtc000) {
22195 jjtree.clearNodeScope(jjtn000);
22196 jjtc000 = false;
22197 } else {
22198 jjtree.popNode();
22199 }
22200 if (jjte000 instanceof RuntimeException) {
22201 {if (true) throw (RuntimeException)jjte000;}
22202 }
22203 if (jjte000 instanceof ParseException) {
22204 {if (true) throw (ParseException)jjte000;}
22205 }
22206 {if (true) throw (Error)jjte000;}
22207 } finally {
22208 if (jjtc000) {
22209 jjtree.closeNodeScope(jjtn000, true);
22210 }
22211 }
22212 throw new Error("Missing return statement in function");
22213 }
22214
22215 final public ASTInlinePragma InlinePragma() throws ParseException {
22216
22217 ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
22218 boolean jjtc000 = true;
22219 jjtree.openNodeScope(jjtn000);
22220 try {
22221 jj_consume_token(PRAGMA);
22222 jj_consume_token(INLINE);
22223 jj_consume_token(5);
22224 QualifiedName();
22225 jj_consume_token(6);
22226 StringLiteral();
22227 jj_consume_token(7);
22228 jjtree.closeNodeScope(jjtn000, true);
22229 jjtc000 = false;
22230 {if (true) return jjtn000 ;}
22231 } catch (Throwable jjte000) {
22232 if (jjtc000) {
22233 jjtree.clearNodeScope(jjtn000);
22234 jjtc000 = false;
22235 } else {
22236 jjtree.popNode();
22237 }
22238 if (jjte000 instanceof RuntimeException) {
22239 {if (true) throw (RuntimeException)jjte000;}
22240 }
22241 if (jjte000 instanceof ParseException) {
22242 {if (true) throw (ParseException)jjte000;}
22243 }
22244 {if (true) throw (Error)jjte000;}
22245 } finally {
22246 if (jjtc000) {
22247 jjtree.closeNodeScope(jjtn000, true);
22248 }
22249 }
22250 throw new Error("Missing return statement in function");
22251 }
22252
22253 final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
22254
22255 ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
22256 boolean jjtc000 = true;
22257 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22258 try {
22259 simpleNode = ID();
22260 jj_consume_token(EXCEPTION);
22261 jj_consume_token(4);
22262 jjtree.closeNodeScope(jjtn000, true);
22263 jjtc000 = false;
22264 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22265 } catch (Throwable jjte000) {
22266 if (jjtc000) {
22267 jjtree.clearNodeScope(jjtn000);
22268 jjtc000 = false;
22269 } else {
22270 jjtree.popNode();
22271 }
22272 if (jjte000 instanceof RuntimeException) {
22273 {if (true) throw (RuntimeException)jjte000;}
22274 }
22275 if (jjte000 instanceof ParseException) {
22276 {if (true) throw (ParseException)jjte000;}
22277 }
22278 {if (true) throw (Error)jjte000;}
22279 } finally {
22280 if (jjtc000) {
22281 jjtree.closeNodeScope(jjtn000, true);
22282 }
22283 }
22284 throw new Error("Missing return statement in function");
22285 }
22286
22287 final public ASTParallelClause ParallelClause() throws ParseException {
22288
22289 ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
22290 boolean jjtc000 = true;
22291 jjtree.openNodeScope(jjtn000);
22292 try {
22293 jj_consume_token(5);
22294 jj_consume_token(PARTITION);
22295 ID();
22296 jj_consume_token(BY);
22297 switch (jj_nt.kind) {
22298 case ANY:
22299 jj_consume_token(ANY);
22300 break;
22301 case HASH:
22302 case RANGE:
22303 switch (jj_nt.kind) {
22304 case HASH:
22305 jj_consume_token(HASH);
22306 break;
22307 case RANGE:
22308 jj_consume_token(RANGE);
22309 break;
22310 default:
22311 jj_la1[287] = jj_gen;
22312 jj_consume_token(-1);
22313 throw new ParseException();
22314 }
22315 jj_consume_token(5);
22316 ID();
22317 label_68:
22318 while (true) {
22319 switch (jj_nt.kind) {
22320 case 6:
22321 ;
22322 break;
22323 default:
22324 jj_la1[288] = jj_gen;
22325 break label_68;
22326 }
22327 jj_consume_token(6);
22328 ID();
22329 }
22330 jj_consume_token(7);
22331 break;
22332 default:
22333 jj_la1[289] = jj_gen;
22334 jj_consume_token(-1);
22335 throw new ParseException();
22336 }
22337 jj_consume_token(7);
22338 switch (jj_nt.kind) {
22339 case CLUSTER:
22340 case ORDER:
22341 switch (jj_nt.kind) {
22342 case ORDER:
22343 jj_consume_token(ORDER);
22344 break;
22345 case CLUSTER:
22346 jj_consume_token(CLUSTER);
22347 break;
22348 default:
22349 jj_la1[290] = jj_gen;
22350 jj_consume_token(-1);
22351 throw new ParseException();
22352 }
22353 jj_consume_token(BY);
22354 jj_consume_token(5);
22355 ID();
22356 label_69:
22357 while (true) {
22358 switch (jj_nt.kind) {
22359 case 6:
22360 ;
22361 break;
22362 default:
22363 jj_la1[291] = jj_gen;
22364 break label_69;
22365 }
22366 jj_consume_token(6);
22367 ID();
22368 }
22369 jj_consume_token(7);
22370 break;
22371 default:
22372 jj_la1[292] = jj_gen;
22373 ;
22374 }
22375 jjtree.closeNodeScope(jjtn000, true);
22376 jjtc000 = false;
22377 {if (true) return jjtn000 ;}
22378 } catch (Throwable jjte000) {
22379 if (jjtc000) {
22380 jjtree.clearNodeScope(jjtn000);
22381 jjtc000 = false;
22382 } else {
22383 jjtree.popNode();
22384 }
22385 if (jjte000 instanceof RuntimeException) {
22386 {if (true) throw (RuntimeException)jjte000;}
22387 }
22388 if (jjte000 instanceof ParseException) {
22389 {if (true) throw (ParseException)jjte000;}
22390 }
22391 {if (true) throw (Error)jjte000;}
22392 } finally {
22393 if (jjtc000) {
22394 jjtree.closeNodeScope(jjtn000, true);
22395 }
22396 }
22397 throw new Error("Missing return statement in function");
22398 }
22399
22400 final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
22401
22402 ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
22403 boolean jjtc000 = true;
22404 jjtree.openNodeScope(jjtn000);
22405 try {
22406 jj_consume_token(ACCESSIBLE);
22407 jj_consume_token(BY);
22408 jj_consume_token(5);
22409 switch (jj_nt.kind) {
22410 case FUNCTION:
22411 case PACKAGE:
22412 case PROCEDURE:
22413 case TRIGGER:
22414 case TYPE:
22415 switch (jj_nt.kind) {
22416 case FUNCTION:
22417 jj_consume_token(FUNCTION);
22418 break;
22419 case PROCEDURE:
22420 jj_consume_token(PROCEDURE);
22421 break;
22422 case PACKAGE:
22423 jj_consume_token(PACKAGE);
22424 break;
22425 case TRIGGER:
22426 jj_consume_token(TRIGGER);
22427 break;
22428 case TYPE:
22429 jj_consume_token(TYPE);
22430 break;
22431 default:
22432 jj_la1[293] = jj_gen;
22433 jj_consume_token(-1);
22434 throw new ParseException();
22435 }
22436 break;
22437 default:
22438 jj_la1[294] = jj_gen;
22439 ;
22440 }
22441 QualifiedName();
22442 label_70:
22443 while (true) {
22444 switch (jj_nt.kind) {
22445 case 6:
22446 ;
22447 break;
22448 default:
22449 jj_la1[295] = jj_gen;
22450 break label_70;
22451 }
22452 jj_consume_token(6);
22453 switch (jj_nt.kind) {
22454 case FUNCTION:
22455 case PACKAGE:
22456 case PROCEDURE:
22457 case TRIGGER:
22458 case TYPE:
22459 switch (jj_nt.kind) {
22460 case FUNCTION:
22461 jj_consume_token(FUNCTION);
22462 break;
22463 case PROCEDURE:
22464 jj_consume_token(PROCEDURE);
22465 break;
22466 case PACKAGE:
22467 jj_consume_token(PACKAGE);
22468 break;
22469 case TRIGGER:
22470 jj_consume_token(TRIGGER);
22471 break;
22472 case TYPE:
22473 jj_consume_token(TYPE);
22474 break;
22475 default:
22476 jj_la1[296] = jj_gen;
22477 jj_consume_token(-1);
22478 throw new ParseException();
22479 }
22480 break;
22481 default:
22482 jj_la1[297] = jj_gen;
22483 ;
22484 }
22485 QualifiedName();
22486 }
22487 jj_consume_token(7);
22488 jjtree.closeNodeScope(jjtn000, true);
22489 jjtc000 = false;
22490 {if (true) return jjtn000 ;}
22491 } catch (Throwable jjte000) {
22492 if (jjtc000) {
22493 jjtree.clearNodeScope(jjtn000);
22494 jjtc000 = false;
22495 } else {
22496 jjtree.popNode();
22497 }
22498 if (jjte000 instanceof RuntimeException) {
22499 {if (true) throw (RuntimeException)jjte000;}
22500 }
22501 if (jjte000 instanceof ParseException) {
22502 {if (true) throw (ParseException)jjte000;}
22503 }
22504 {if (true) throw (Error)jjte000;}
22505 } finally {
22506 if (jjtc000) {
22507 jjtree.closeNodeScope(jjtn000, true);
22508 }
22509 }
22510 throw new Error("Missing return statement in function");
22511 }
22512
22513
22514
22515
22516
22517
22518
22519
22520 final public ASTTable Table() throws ParseException {
22521
22522 ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
22523 boolean jjtc000 = true;
22524 jjtree.openNodeScope(jjtn000);
22525 try {
22526 jj_consume_token(CREATE);
22527 switch (jj_nt.kind) {
22528 case GLOBAL:
22529 jj_consume_token(GLOBAL);
22530 jj_consume_token(TEMPORARY);
22531 break;
22532 default:
22533 jj_la1[298] = jj_gen;
22534 ;
22535 }
22536 jj_consume_token(TABLE);
22537 ObjectNameDeclaration();
22538 jj_consume_token(5);
22539 TableColumn();
22540 label_71:
22541 while (true) {
22542 switch (jj_nt.kind) {
22543 case 6:
22544 ;
22545 break;
22546 default:
22547 jj_la1[299] = jj_gen;
22548 break label_71;
22549 }
22550 jj_consume_token(6);
22551 TableColumn();
22552 }
22553 jj_consume_token(7);
22554 if (jj_2_60(2)) {
22555 jj_consume_token(ON);
22556 jj_consume_token(COMMIT);
22557 switch (jj_nt.kind) {
22558 case DELETE:
22559 jj_consume_token(DELETE);
22560 break;
22561 case PRESERVE:
22562 jj_consume_token(PRESERVE);
22563 break;
22564 default:
22565 jj_la1[300] = jj_gen;
22566 jj_consume_token(-1);
22567 throw new ParseException();
22568 }
22569 jj_consume_token(ROWS);
22570 } else {
22571 ;
22572 }
22573 switch (jj_nt.kind) {
22574 case 4:
22575 jj_consume_token(4);
22576 break;
22577 default:
22578 jj_la1[301] = jj_gen;
22579 ;
22580 }
22581 jjtree.closeNodeScope(jjtn000, true);
22582 jjtc000 = false;
22583 {if (true) return jjtn000 ;}
22584 } catch (Throwable jjte000) {
22585 if (jjtc000) {
22586 jjtree.clearNodeScope(jjtn000);
22587 jjtc000 = false;
22588 } else {
22589 jjtree.popNode();
22590 }
22591 if (jjte000 instanceof RuntimeException) {
22592 {if (true) throw (RuntimeException)jjte000;}
22593 }
22594 if (jjte000 instanceof ParseException) {
22595 {if (true) throw (ParseException)jjte000;}
22596 }
22597 {if (true) throw (Error)jjte000;}
22598 } finally {
22599 if (jjtc000) {
22600 jjtree.closeNodeScope(jjtn000, true);
22601 }
22602 }
22603 throw new Error("Missing return statement in function");
22604 }
22605
22606 final public ASTTableColumn TableColumn() throws ParseException {
22607
22608 ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
22609 boolean jjtc000 = true;
22610 jjtree.openNodeScope(jjtn000);
22611 try {
22612 ID();
22613 Datatype();
22614 switch (jj_nt.kind) {
22615 case _DEFAULT:
22616 jj_consume_token(_DEFAULT);
22617 Expression();
22618 break;
22619 default:
22620 jj_la1[302] = jj_gen;
22621 ;
22622 }
22623 switch (jj_nt.kind) {
22624 case NOT:
22625 case NULL:
22626 switch (jj_nt.kind) {
22627 case NOT:
22628 jj_consume_token(NOT);
22629 break;
22630 default:
22631 jj_la1[303] = jj_gen;
22632 ;
22633 }
22634 jj_consume_token(NULL);
22635 break;
22636 default:
22637 jj_la1[304] = jj_gen;
22638 ;
22639 }
22640 jjtree.closeNodeScope(jjtn000, true);
22641 jjtc000 = false;
22642 {if (true) return jjtn000 ;}
22643 } catch (Throwable jjte000) {
22644 if (jjtc000) {
22645 jjtree.clearNodeScope(jjtn000);
22646 jjtc000 = false;
22647 } else {
22648 jjtree.popNode();
22649 }
22650 if (jjte000 instanceof RuntimeException) {
22651 {if (true) throw (RuntimeException)jjte000;}
22652 }
22653 if (jjte000 instanceof ParseException) {
22654 {if (true) throw (ParseException)jjte000;}
22655 }
22656 {if (true) throw (Error)jjte000;}
22657 } finally {
22658 if (jjtc000) {
22659 jjtree.closeNodeScope(jjtn000, true);
22660 }
22661 }
22662 throw new Error("Missing return statement in function");
22663 }
22664
22665 final public ASTView View() throws ParseException {
22666
22667 ASTView jjtn000 = new ASTView(this, JJTVIEW);
22668 boolean jjtc000 = true;
22669 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22670 try {
22671 jj_consume_token(CREATE);
22672 switch (jj_nt.kind) {
22673 case OR:
22674 jj_consume_token(OR);
22675 jj_consume_token(REPLACE);
22676 break;
22677 default:
22678 jj_la1[305] = jj_gen;
22679 ;
22680 }
22681 switch (jj_nt.kind) {
22682 case FORCE:
22683 case NO:
22684 switch (jj_nt.kind) {
22685 case NO:
22686 jj_consume_token(NO);
22687 break;
22688 default:
22689 jj_la1[306] = jj_gen;
22690 ;
22691 }
22692 jj_consume_token(FORCE);
22693 break;
22694 default:
22695 jj_la1[307] = jj_gen;
22696 ;
22697 }
22698 jj_consume_token(VIEW);
22699 simpleNode = ObjectNameDeclaration();
22700 switch (jj_nt.kind) {
22701 case 5:
22702 jj_consume_token(5);
22703 ViewColumn();
22704 label_72:
22705 while (true) {
22706 switch (jj_nt.kind) {
22707 case 6:
22708 ;
22709 break;
22710 default:
22711 jj_la1[308] = jj_gen;
22712 break label_72;
22713 }
22714 jj_consume_token(6);
22715 ViewColumn();
22716 }
22717 jj_consume_token(7);
22718 break;
22719 default:
22720 jj_la1[309] = jj_gen;
22721 ;
22722 }
22723 jj_consume_token(AS);
22724 Statement();
22725 switch (jj_nt.kind) {
22726 case 4:
22727 jj_consume_token(4);
22728 break;
22729 case 1:
22730 jj_consume_token(1);
22731 break;
22732 default:
22733 jj_la1[310] = jj_gen;
22734 jj_consume_token(-1);
22735 throw new ParseException();
22736 }
22737 jjtree.closeNodeScope(jjtn000, true);
22738 jjtc000 = false;
22739 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22740 } catch (Throwable jjte000) {
22741 if (jjtc000) {
22742 jjtree.clearNodeScope(jjtn000);
22743 jjtc000 = false;
22744 } else {
22745 jjtree.popNode();
22746 }
22747 if (jjte000 instanceof RuntimeException) {
22748 {if (true) throw (RuntimeException)jjte000;}
22749 }
22750 if (jjte000 instanceof ParseException) {
22751 {if (true) throw (ParseException)jjte000;}
22752 }
22753 {if (true) throw (Error)jjte000;}
22754 } finally {
22755 if (jjtc000) {
22756 jjtree.closeNodeScope(jjtn000, true);
22757 }
22758 }
22759 throw new Error("Missing return statement in function");
22760 }
22761
22762 final public ASTSynonym Synonym() throws ParseException {
22763
22764 ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22765 boolean jjtc000 = true;
22766 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22767 try {
22768 jj_consume_token(CREATE);
22769 switch (jj_nt.kind) {
22770 case OR:
22771 jj_consume_token(OR);
22772 jj_consume_token(REPLACE);
22773 break;
22774 default:
22775 jj_la1[311] = jj_gen;
22776 ;
22777 }
22778 switch (jj_nt.kind) {
22779 case PUBLIC:
22780 jj_consume_token(PUBLIC);
22781 break;
22782 default:
22783 jj_la1[312] = jj_gen;
22784 ;
22785 }
22786 jj_consume_token(SYNONYM);
22787 simpleNode = ObjectNameDeclaration();
22788 jj_consume_token(FOR);
22789 ObjectNameDeclaration();
22790 switch (jj_nt.kind) {
22791 case 4:
22792 jj_consume_token(4);
22793 break;
22794 case 1:
22795 jj_consume_token(1);
22796 break;
22797 default:
22798 jj_la1[313] = jj_gen;
22799 jj_consume_token(-1);
22800 throw new ParseException();
22801 }
22802 jjtree.closeNodeScope(jjtn000, true);
22803 jjtc000 = false;
22804 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22805 } catch (Throwable jjte000) {
22806 if (jjtc000) {
22807 jjtree.clearNodeScope(jjtn000);
22808 jjtc000 = false;
22809 } else {
22810 jjtree.popNode();
22811 }
22812 if (jjte000 instanceof RuntimeException) {
22813 {if (true) throw (RuntimeException)jjte000;}
22814 }
22815 if (jjte000 instanceof ParseException) {
22816 {if (true) throw (ParseException)jjte000;}
22817 }
22818 {if (true) throw (Error)jjte000;}
22819 } finally {
22820 if (jjtc000) {
22821 jjtree.closeNodeScope(jjtn000, true);
22822 }
22823 }
22824 throw new Error("Missing return statement in function");
22825 }
22826
22827 final public ASTDirectory Directory() throws ParseException {
22828
22829 ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22830 boolean jjtc000 = true;
22831 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22832 try {
22833 jj_consume_token(CREATE);
22834 switch (jj_nt.kind) {
22835 case OR:
22836 jj_consume_token(OR);
22837 jj_consume_token(REPLACE);
22838 break;
22839 default:
22840 jj_la1[314] = jj_gen;
22841 ;
22842 }
22843 jj_consume_token(DIRECTORY);
22844 simpleNode = ObjectNameDeclaration();
22845 jj_consume_token(AS);
22846 StringLiteral();
22847 switch (jj_nt.kind) {
22848 case 4:
22849 jj_consume_token(4);
22850 break;
22851 case 1:
22852 jj_consume_token(1);
22853 break;
22854 default:
22855 jj_la1[315] = jj_gen;
22856 jj_consume_token(-1);
22857 throw new ParseException();
22858 }
22859 jjtree.closeNodeScope(jjtn000, true);
22860 jjtc000 = false;
22861 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22862 } catch (Throwable jjte000) {
22863 if (jjtc000) {
22864 jjtree.clearNodeScope(jjtn000);
22865 jjtc000 = false;
22866 } else {
22867 jjtree.popNode();
22868 }
22869 if (jjte000 instanceof RuntimeException) {
22870 {if (true) throw (RuntimeException)jjte000;}
22871 }
22872 if (jjte000 instanceof ParseException) {
22873 {if (true) throw (ParseException)jjte000;}
22874 }
22875 {if (true) throw (Error)jjte000;}
22876 } finally {
22877 if (jjtc000) {
22878 jjtree.closeNodeScope(jjtn000, true);
22879 }
22880 }
22881 throw new Error("Missing return statement in function");
22882 }
22883
22884 final public ASTDatabaseLink DatabaseLink() throws ParseException {
22885
22886 ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22887 boolean jjtc000 = true;
22888 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22889 try {
22890 jj_consume_token(CREATE);
22891 switch (jj_nt.kind) {
22892 case SHARED:
22893 jj_consume_token(SHARED);
22894 break;
22895 default:
22896 jj_la1[316] = jj_gen;
22897 ;
22898 }
22899 switch (jj_nt.kind) {
22900 case PUBLIC:
22901 jj_consume_token(PUBLIC);
22902 break;
22903 default:
22904 jj_la1[317] = jj_gen;
22905 ;
22906 }
22907 jj_consume_token(DATABASE);
22908 jj_consume_token(LINK);
22909 simpleNode = ObjectNameDeclaration();
22910 switch (jj_nt.kind) {
22911 case CONNECT:
22912 jj_consume_token(CONNECT);
22913 jj_consume_token(TO);
22914 switch (jj_nt.kind) {
22915 case CURRENT_USER:
22916 jj_consume_token(CURRENT_USER);
22917 break;
22918 case REPLACE:
22919 case DEFINER:
22920 case LANGUAGE:
22921 case INLINE:
22922 case ADD:
22923 case AGGREGATE:
22924 case ARRAY:
22925 case AT:
22926 case ATTRIBUTE:
22927 case AUTHID:
22928 case BODY:
22929 case BULK:
22930 case BYTE:
22931 case CASCADE:
22932 case CLOSE:
22933 case COALESCE:
22934 case COLLECT:
22935 case COLUMN:
22936 case COMMENT:
22937 case COMMIT:
22938 case CONSTRUCTOR:
22939 case CONTINUE:
22940 case CONVERT:
22941 case CURRENT:
22942 case CURSOR:
22943 case DATA:
22944 case DAY:
22945 case DISABLE:
22946 case EDITIONABLE:
22947 case ELEMENT:
22948 case ENABLE:
22949 case ESCAPE:
22950 case EXCEPT:
22951 case EXCEPTIONS:
22952 case EXIT:
22953 case EXTERNAL:
22954 case EXTENDS:
22955 case EXTRACT:
22956 case FALSE:
22957 case FINAL:
22958 case FORCE:
22959 case FUNCTION:
22960 case GLOBAL:
22961 case HASH:
22962 case HEAP:
22963 case HOUR:
22964 case IMMEDIATE:
22965 case INDICES:
22966 case INDEXTYPE:
22967 case INDICATOR:
22968 case INSTANTIABLE:
22969 case INTERVAL:
22970 case INVALIDATE:
22971 case ISOLATION:
22972 case JAVA:
22973 case LEVEL:
22974 case LIMIT:
22975 case LOOP:
22976 case MAP:
22977 case MAX:
22978 case MEMBER:
22979 case MERGE:
22980 case MIN:
22981 case MINUTE:
22982 case MLSLABEL:
22983 case MODIFY:
22984 case MOD:
22985 case MONTH:
22986 case NATURAL:
22987 case NEW:
22988 case NO:
22989 case NONEDITIONABLE:
22990 case NULLIF:
22991 case OBJECT:
22992 case OID:
22993 case OPAQUE:
22994 case OPEN:
22995 case OPERATOR:
22996 case ORGANIZATION:
22997 case OTHERS:
22998 case OVERRIDING:
22999 case PACKAGE:
23000 case PARTITION:
23001 case PRESERVE:
23002 case PRIVATE:
23003 case PROCEDURE:
23004 case RANGE:
23005 case RAW:
23006 case REAL:
23007 case RECORD:
23008 case REF:
23009 case RELEASE:
23010 case RELIES_ON:
23011 case RENAME:
23012 case RESULT:
23013 case RETURN:
23014 case RETURNING:
23015 case REVERSE:
23016 case ROLLBACK:
23017 case ROW:
23018 case ROWS:
23019 case ROWID:
23020 case ROWNUM:
23021 case SAVE:
23022 case SAVEPOINT:
23023 case SECOND:
23024 case SELF:
23025 case SET:
23026 case SPACE:
23027 case SQL:
23028 case SQLCODE:
23029 case SQLERRM:
23030 case STATIC:
23031 case SUBTYPE:
23032 case SUBSTITUTABLE:
23033 case SUCCESSFUL:
23034 case SYSDATE:
23035 case SYS_REFCURSOR:
23036 case TEMPORARY:
23037 case TIME:
23038 case TIMESTAMP:
23039 case TIMEZONE_REGION:
23040 case TIMEZONE_ABBR:
23041 case TIMEZONE_MINUTE:
23042 case TIMEZONE_HOUR:
23043 case TRANSACTION:
23044 case TRUE:
23045 case TYPE:
23046 case UNDER:
23047 case USING:
23048 case YES:
23049 case SHOW:
23050 case A:
23051 case DOUBLE:
23052 case DEC:
23053 case PRECISION:
23054 case INT:
23055 case NUMERIC:
23056 case NCHAR:
23057 case NVARCHAR2:
23058 case STRING:
23059 case UROWID:
23060 case VARRAY:
23061 case VARYING:
23062 case BFILE:
23063 case BLOB:
23064 case CLOB:
23065 case NCLOB:
23066 case YEAR:
23067 case LOCAL:
23068 case ZONE:
23069 case CHARACTER:
23070 case AFTER:
23071 case BEFORE:
23072 case OLD:
23073 case PARENT:
23074 case ANALYZE:
23075 case ASSOCIATE:
23076 case AUDIT:
23077 case COMPOUND:
23078 case DATABASE:
23079 case CALL:
23080 case DDL:
23081 case DISASSOCIATE:
23082 case EACH:
23083 case FOLLOWS:
23084 case LOGOFF:
23085 case LOGON:
23086 case NESTED:
23087 case NOAUDIT:
23088 case SCHEMA:
23089 case SERVERERROR:
23090 case SHUTDOWN:
23091 case STARTUP:
23092 case STATEMENT:
23093 case STATISTICS:
23094 case SUSPEND:
23095 case TRUNCATE:
23096 case WRAPPED:
23097 case LIBRARY:
23098 case NAME:
23099 case STRUCT:
23100 case CONTEXT:
23101 case PARAMETERS:
23102 case LENGTH:
23103 case TDO:
23104 case MAXLEN:
23105 case CHARSETID:
23106 case CHARSETFORM:
23107 case ACCEPT:
23108 case ACCESSIBLE:
23109 case COPY:
23110 case DEFINE:
23111 case DISCONNECT:
23112 case HOST:
23113 case PRINT:
23114 case QUIT:
23115 case REMARK:
23116 case UNDEFINE:
23117 case VARIABLE:
23118 case WHENEVER:
23119 case ATTACH:
23120 case CAST:
23121 case TREAT:
23122 case TRIM:
23123 case LEFT:
23124 case RIGHT:
23125 case BOTH:
23126 case EMPTY:
23127 case MULTISET:
23128 case SUBMULTISET:
23129 case LEADING:
23130 case TRAILING:
23131 case CHAR_CS:
23132 case NCHAR_CS:
23133 case DBTIMEZONE:
23134 case SESSIONTIMEZONE:
23135 case AUTHENTICATED:
23136 case LINK:
23137 case SHARED:
23138 case DIRECTORY:
23139 case USER:
23140 case IDENTIFIER:
23141 case QUOTED_LITERAL:
23142 UnqualifiedID();
23143 jj_consume_token(IDENTIFIED);
23144 jj_consume_token(BY);
23145 UnqualifiedID();
23146 jj_consume_token(AUTHENTICATED);
23147 jj_consume_token(BY);
23148 UnqualifiedID();
23149 jj_consume_token(IDENTIFIED);
23150 jj_consume_token(BY);
23151 UnqualifiedID();
23152 break;
23153 default:
23154 jj_la1[318] = jj_gen;
23155 jj_consume_token(-1);
23156 throw new ParseException();
23157 }
23158 break;
23159 case REPLACE:
23160 case DEFINER:
23161 case CURRENT_USER:
23162 case LANGUAGE:
23163 case INLINE:
23164 case ADD:
23165 case AGGREGATE:
23166 case ARRAY:
23167 case AT:
23168 case ATTRIBUTE:
23169 case AUTHID:
23170 case BODY:
23171 case BULK:
23172 case BYTE:
23173 case CASCADE:
23174 case CLOSE:
23175 case COALESCE:
23176 case COLLECT:
23177 case COLUMN:
23178 case COMMENT:
23179 case COMMIT:
23180 case CONSTRUCTOR:
23181 case CONTINUE:
23182 case CONVERT:
23183 case CURRENT:
23184 case CURSOR:
23185 case DATA:
23186 case DAY:
23187 case DISABLE:
23188 case EDITIONABLE:
23189 case ELEMENT:
23190 case ENABLE:
23191 case ESCAPE:
23192 case EXCEPT:
23193 case EXCEPTIONS:
23194 case EXIT:
23195 case EXTERNAL:
23196 case EXTENDS:
23197 case EXTRACT:
23198 case FALSE:
23199 case FINAL:
23200 case FORCE:
23201 case FUNCTION:
23202 case GLOBAL:
23203 case HASH:
23204 case HEAP:
23205 case HOUR:
23206 case IMMEDIATE:
23207 case INDICES:
23208 case INDEXTYPE:
23209 case INDICATOR:
23210 case INSTANTIABLE:
23211 case INTERVAL:
23212 case INVALIDATE:
23213 case ISOLATION:
23214 case JAVA:
23215 case LEVEL:
23216 case LIMIT:
23217 case LOOP:
23218 case MAP:
23219 case MAX:
23220 case MEMBER:
23221 case MERGE:
23222 case MIN:
23223 case MINUTE:
23224 case MLSLABEL:
23225 case MODIFY:
23226 case MOD:
23227 case MONTH:
23228 case NATURAL:
23229 case NEW:
23230 case NO:
23231 case NONEDITIONABLE:
23232 case NULLIF:
23233 case OBJECT:
23234 case OID:
23235 case OPAQUE:
23236 case OPEN:
23237 case OPERATOR:
23238 case ORGANIZATION:
23239 case OTHERS:
23240 case OVERRIDING:
23241 case PACKAGE:
23242 case PARTITION:
23243 case PRESERVE:
23244 case PRIVATE:
23245 case PROCEDURE:
23246 case RANGE:
23247 case RAW:
23248 case REAL:
23249 case RECORD:
23250 case REF:
23251 case RELEASE:
23252 case RELIES_ON:
23253 case RENAME:
23254 case RESULT:
23255 case RETURN:
23256 case RETURNING:
23257 case REVERSE:
23258 case ROLLBACK:
23259 case ROW:
23260 case ROWS:
23261 case ROWID:
23262 case ROWNUM:
23263 case SAVE:
23264 case SAVEPOINT:
23265 case SECOND:
23266 case SELF:
23267 case SET:
23268 case SPACE:
23269 case SQL:
23270 case SQLCODE:
23271 case SQLERRM:
23272 case STATIC:
23273 case SUBTYPE:
23274 case SUBSTITUTABLE:
23275 case SUCCESSFUL:
23276 case SYSDATE:
23277 case SYS_REFCURSOR:
23278 case TEMPORARY:
23279 case TIME:
23280 case TIMESTAMP:
23281 case TIMEZONE_REGION:
23282 case TIMEZONE_ABBR:
23283 case TIMEZONE_MINUTE:
23284 case TIMEZONE_HOUR:
23285 case TRANSACTION:
23286 case TRUE:
23287 case TYPE:
23288 case UNDER:
23289 case USING:
23290 case YES:
23291 case SHOW:
23292 case A:
23293 case DOUBLE:
23294 case DEC:
23295 case PRECISION:
23296 case INT:
23297 case NUMERIC:
23298 case NCHAR:
23299 case NVARCHAR2:
23300 case STRING:
23301 case UROWID:
23302 case VARRAY:
23303 case VARYING:
23304 case BFILE:
23305 case BLOB:
23306 case CLOB:
23307 case NCLOB:
23308 case YEAR:
23309 case LOCAL:
23310 case ZONE:
23311 case CHARACTER:
23312 case AFTER:
23313 case BEFORE:
23314 case OLD:
23315 case PARENT:
23316 case ANALYZE:
23317 case ASSOCIATE:
23318 case AUDIT:
23319 case COMPOUND:
23320 case DATABASE:
23321 case CALL:
23322 case DDL:
23323 case DISASSOCIATE:
23324 case EACH:
23325 case FOLLOWS:
23326 case LOGOFF:
23327 case LOGON:
23328 case NESTED:
23329 case NOAUDIT:
23330 case SCHEMA:
23331 case SERVERERROR:
23332 case SHUTDOWN:
23333 case STARTUP:
23334 case STATEMENT:
23335 case STATISTICS:
23336 case SUSPEND:
23337 case TRUNCATE:
23338 case WRAPPED:
23339 case LIBRARY:
23340 case NAME:
23341 case STRUCT:
23342 case CONTEXT:
23343 case PARAMETERS:
23344 case LENGTH:
23345 case TDO:
23346 case MAXLEN:
23347 case CHARSETID:
23348 case CHARSETFORM:
23349 case ACCEPT:
23350 case ACCESSIBLE:
23351 case COPY:
23352 case DEFINE:
23353 case DISCONNECT:
23354 case HOST:
23355 case PRINT:
23356 case QUIT:
23357 case REMARK:
23358 case UNDEFINE:
23359 case VARIABLE:
23360 case WHENEVER:
23361 case ATTACH:
23362 case CAST:
23363 case TREAT:
23364 case TRIM:
23365 case LEFT:
23366 case RIGHT:
23367 case BOTH:
23368 case EMPTY:
23369 case MULTISET:
23370 case SUBMULTISET:
23371 case LEADING:
23372 case TRAILING:
23373 case CHAR_CS:
23374 case NCHAR_CS:
23375 case DBTIMEZONE:
23376 case SESSIONTIMEZONE:
23377 case AUTHENTICATED:
23378 case LINK:
23379 case SHARED:
23380 case DIRECTORY:
23381 case USER:
23382 case IDENTIFIER:
23383 case QUOTED_LITERAL:
23384 UnqualifiedID();
23385 jj_consume_token(IDENTIFIED);
23386 jj_consume_token(BY);
23387 UnqualifiedID();
23388 break;
23389 default:
23390 jj_la1[319] = jj_gen;
23391 jj_consume_token(-1);
23392 throw new ParseException();
23393 }
23394 switch (jj_nt.kind) {
23395 case USING:
23396 jj_consume_token(USING);
23397 StringLiteral();
23398 break;
23399 default:
23400 jj_la1[320] = jj_gen;
23401 ;
23402 }
23403 switch (jj_nt.kind) {
23404 case 4:
23405 jj_consume_token(4);
23406 break;
23407 case 1:
23408 jj_consume_token(1);
23409 break;
23410 default:
23411 jj_la1[321] = jj_gen;
23412 jj_consume_token(-1);
23413 throw new ParseException();
23414 }
23415 jjtree.closeNodeScope(jjtn000, true);
23416 jjtc000 = false;
23417 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
23418 } catch (Throwable jjte000) {
23419 if (jjtc000) {
23420 jjtree.clearNodeScope(jjtn000);
23421 jjtc000 = false;
23422 } else {
23423 jjtree.popNode();
23424 }
23425 if (jjte000 instanceof RuntimeException) {
23426 {if (true) throw (RuntimeException)jjte000;}
23427 }
23428 if (jjte000 instanceof ParseException) {
23429 {if (true) throw (ParseException)jjte000;}
23430 }
23431 {if (true) throw (Error)jjte000;}
23432 } finally {
23433 if (jjtc000) {
23434 jjtree.closeNodeScope(jjtn000, true);
23435 }
23436 }
23437 throw new Error("Missing return statement in function");
23438 }
23439
23440 final public ASTViewColumn ViewColumn() throws ParseException {
23441
23442 ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
23443 boolean jjtc000 = true;
23444 jjtree.openNodeScope(jjtn000);
23445 try {
23446 ID();
23447 jjtree.closeNodeScope(jjtn000, true);
23448 jjtc000 = false;
23449 {if (true) return jjtn000 ;}
23450 } catch (Throwable jjte000) {
23451 if (jjtc000) {
23452 jjtree.clearNodeScope(jjtn000);
23453 jjtc000 = false;
23454 } else {
23455 jjtree.popNode();
23456 }
23457 if (jjte000 instanceof RuntimeException) {
23458 {if (true) throw (RuntimeException)jjte000;}
23459 }
23460 if (jjte000 instanceof ParseException) {
23461 {if (true) throw (ParseException)jjte000;}
23462 }
23463 {if (true) throw (Error)jjte000;}
23464 } finally {
23465 if (jjtc000) {
23466 jjtree.closeNodeScope(jjtn000, true);
23467 }
23468 }
23469 throw new Error("Missing return statement in function");
23470 }
23471
23472 final public ASTComment Comment() throws ParseException {
23473
23474 ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
23475 boolean jjtc000 = true;
23476 jjtree.openNodeScope(jjtn000);
23477 try {
23478 jj_consume_token(COMMENT);
23479 jj_consume_token(ON);
23480 switch (jj_nt.kind) {
23481 case INDEXTYPE:
23482 case OPERATOR:
23483 case TABLE:
23484 switch (jj_nt.kind) {
23485 case TABLE:
23486 jj_consume_token(TABLE);
23487 break;
23488 case OPERATOR:
23489 jj_consume_token(OPERATOR);
23490 break;
23491 case INDEXTYPE:
23492 jj_consume_token(INDEXTYPE);
23493 break;
23494 default:
23495 jj_la1[322] = jj_gen;
23496 jj_consume_token(-1);
23497 throw new ParseException();
23498 }
23499 if (jj_2_61(2)) {
23500 ID();
23501 jj_consume_token(3);
23502 } else {
23503 ;
23504 }
23505 ID();
23506 break;
23507 case COLUMN:
23508 jj_consume_token(COLUMN);
23509 if (jj_2_62(2147483647)) {
23510 ID();
23511 jj_consume_token(3);
23512 } else {
23513 ;
23514 }
23515 ID();
23516 jj_consume_token(3);
23517 ID();
23518 break;
23519 default:
23520 jj_la1[323] = jj_gen;
23521 jj_consume_token(-1);
23522 throw new ParseException();
23523 }
23524 jj_consume_token(IS);
23525 jj_consume_token(STRING_LITERAL);
23526 switch (jj_nt.kind) {
23527 case 4:
23528 jj_consume_token(4);
23529 break;
23530 default:
23531 jj_la1[324] = jj_gen;
23532 ;
23533 }
23534 jjtree.closeNodeScope(jjtn000, true);
23535 jjtc000 = false;
23536 {if (true) return jjtn000 ;}
23537 } catch (Throwable jjte000) {
23538 if (jjtc000) {
23539 jjtree.clearNodeScope(jjtn000);
23540 jjtc000 = false;
23541 } else {
23542 jjtree.popNode();
23543 }
23544 if (jjte000 instanceof RuntimeException) {
23545 {if (true) throw (RuntimeException)jjte000;}
23546 }
23547 if (jjte000 instanceof ParseException) {
23548 {if (true) throw (ParseException)jjte000;}
23549 }
23550 {if (true) throw (Error)jjte000;}
23551 } finally {
23552 if (jjtc000) {
23553 jjtree.closeNodeScope(jjtn000, true);
23554 }
23555 }
23556 throw new Error("Missing return statement in function");
23557 }
23558
23559
23560 final public ASTTypeMethod TypeMethod() throws ParseException {
23561
23562 ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
23563 boolean jjtc000 = true;
23564 jjtree.openNodeScope(jjtn000);
23565 try {
23566 getToken(1);
23567
23568
23569 label_73:
23570 while (true) {
23571 switch (jj_nt.kind) {
23572 case FINAL:
23573 case INSTANTIABLE:
23574 case NOT:
23575 case OVERRIDING:
23576 ;
23577 break;
23578 default:
23579 jj_la1[325] = jj_gen;
23580 break label_73;
23581 }
23582 switch (jj_nt.kind) {
23583 case NOT:
23584 jj_consume_token(NOT);
23585 break;
23586 default:
23587 jj_la1[326] = jj_gen;
23588 ;
23589 }
23590 switch (jj_nt.kind) {
23591 case OVERRIDING:
23592 jj_consume_token(OVERRIDING);
23593 break;
23594 case INSTANTIABLE:
23595 jj_consume_token(INSTANTIABLE);
23596 break;
23597 case FINAL:
23598 jj_consume_token(FINAL);
23599 break;
23600 default:
23601 jj_la1[327] = jj_gen;
23602 jj_consume_token(-1);
23603 throw new ParseException();
23604 }
23605 }
23606 switch (jj_nt.kind) {
23607 case MAP:
23608 case ORDER:
23609 switch (jj_nt.kind) {
23610 case MAP:
23611 jj_consume_token(MAP);
23612 break;
23613 case ORDER:
23614 jj_consume_token(ORDER);
23615 break;
23616 default:
23617 jj_la1[328] = jj_gen;
23618 jj_consume_token(-1);
23619 throw new ParseException();
23620 }
23621 break;
23622 default:
23623 jj_la1[329] = jj_gen;
23624 ;
23625 }
23626 switch (jj_nt.kind) {
23627 case CONSTRUCTOR:
23628 jj_consume_token(CONSTRUCTOR);
23629 break;
23630 case MEMBER:
23631 jj_consume_token(MEMBER);
23632 break;
23633 case STATIC:
23634 jj_consume_token(STATIC);
23635 break;
23636 default:
23637 jj_la1[330] = jj_gen;
23638 jj_consume_token(-1);
23639 throw new ParseException();
23640 }
23641 MethodDeclarator();
23642 switch (jj_nt.kind) {
23643 case DETERMINISTIC:
23644 jj_consume_token(DETERMINISTIC);
23645 break;
23646 default:
23647 jj_la1[331] = jj_gen;
23648 ;
23649 }
23650 switch (jj_nt.kind) {
23651 case PARALLEL_ENABLE:
23652 jj_consume_token(PARALLEL_ENABLE);
23653 break;
23654 default:
23655 jj_la1[332] = jj_gen;
23656 ;
23657 }
23658 switch (jj_nt.kind) {
23659 case PIPELINED:
23660 jj_consume_token(PIPELINED);
23661 break;
23662 default:
23663 jj_la1[333] = jj_gen;
23664 ;
23665 }
23666 switch (jj_nt.kind) {
23667 case RESULT_CACHE:
23668 jj_consume_token(RESULT_CACHE);
23669 break;
23670 default:
23671 jj_la1[334] = jj_gen;
23672 ;
23673 }
23674 switch (jj_nt.kind) {
23675 case AS:
23676 case IS:
23677 switch (jj_nt.kind) {
23678 case IS:
23679 jj_consume_token(IS);
23680 break;
23681 case AS:
23682 jj_consume_token(AS);
23683 break;
23684 default:
23685 jj_la1[335] = jj_gen;
23686 jj_consume_token(-1);
23687 throw new ParseException();
23688 }
23689 switch (jj_nt.kind) {
23690 case LANGUAGE:
23691 case EXTERNAL:
23692 CallSpecTail();
23693 switch (jj_nt.kind) {
23694 case 4:
23695 jj_consume_token(4);
23696 break;
23697 default:
23698 jj_la1[336] = jj_gen;
23699 ;
23700 }
23701 break;
23702 case REPLACE:
23703 case DEFINER:
23704 case CURRENT_USER:
23705 case SERIALLY_REUSABLE:
23706 case RESTRICT_REFERENCES:
23707 case EXCEPTION_INIT:
23708 case AUTONOMOUS_TRANSACTION:
23709 case INLINE:
23710 case ADD:
23711 case AGGREGATE:
23712 case ALL:
23713 case ALTER:
23714 case AND:
23715 case ANY:
23716 case ARRAY:
23717 case AS:
23718 case ASC:
23719 case AT:
23720 case ATTRIBUTE:
23721 case AUTHID:
23722 case AVG:
23723 case BEGIN:
23724 case BETWEEN:
23725 case BINARY_INTEGER:
23726 case BODY:
23727 case BOOLEAN:
23728 case BULK:
23729 case BY:
23730 case BYTE:
23731 case CASCADE:
23732 case CASE:
23733 case CHAR:
23734 case CHAR_BASE:
23735 case CHECK:
23736 case CLOSE:
23737 case CLUSTER:
23738 case COALESCE:
23739 case COLLECT:
23740 case COLUMN:
23741 case COMMENT:
23742 case COMMIT:
23743 case COMPRESS:
23744 case CONNECT:
23745 case CONSTANT:
23746 case CONSTRUCTOR:
23747 case CONTINUE:
23748 case CONVERT:
23749 case CREATE:
23750 case CURRENT:
23751 case CURRVAL:
23752 case CURSOR:
23753 case DATA:
23754 case DATE:
23755 case DAY:
23756 case DECLARE:
23757 case DECIMAL:
23758 case _DEFAULT:
23759 case DELETE:
23760 case DESC:
23761 case DISABLE:
23762 case DISTINCT:
23763 case DO:
23764 case DROP:
23765 case EDITIONABLE:
23766 case ELEMENT:
23767 case ELSE:
23768 case ELSIF:
23769 case ENABLE:
23770 case ESCAPE:
23771 case EXCEPT:
23772 case EXCEPTION:
23773 case EXCEPTIONS:
23774 case EXCLUSIVE:
23775 case EXECUTE:
23776 case EXISTS:
23777 case EXIT:
23778 case EXTENDS:
23779 case EXTRACT:
23780 case FALSE:
23781 case FETCH:
23782 case FINAL:
23783 case FLOAT:
23784 case FOR:
23785 case FORALL:
23786 case FORCE:
23787 case FROM:
23788 case FUNCTION:
23789 case GLOBAL:
23790 case GOTO:
23791 case GROUP:
23792 case HASH:
23793 case HAVING:
23794 case HEAP:
23795 case HOUR:
23796 case IF:
23797 case IMMEDIATE:
23798 case IN:
23799 case INDEX:
23800 case INDICES:
23801 case INDEXTYPE:
23802 case INDICATOR:
23803 case INSERT:
23804 case INSTANTIABLE:
23805 case INTEGER:
23806 case INTERFACE:
23807 case INTERSECT:
23808 case INTERVAL:
23809 case INTO:
23810 case INVALIDATE:
23811 case IS:
23812 case ISOLATION:
23813 case JAVA:
23814 case LEVEL:
23815 case LIKE:
23816 case LIMIT:
23817 case LIMITED:
23818 case LOCK:
23819 case LONG:
23820 case LOOP:
23821 case MAP:
23822 case MAX:
23823 case MEMBER:
23824 case MERGE:
23825 case MIN:
23826 case MINUS:
23827 case MINUTE:
23828 case MLSLABEL:
23829 case MODIFY:
23830 case MOD:
23831 case MODE:
23832 case MONTH:
23833 case NATURAL:
23834 case NATURALN:
23835 case NEW:
23836 case NEXTVAL:
23837 case NO:
23838 case NOCOPY:
23839 case NONEDITIONABLE:
23840 case NOT:
23841 case NOWAIT:
23842 case NULL:
23843 case NULLIF:
23844 case NUMBER:
23845 case BFILE_BASE:
23846 case BLOB_BASE:
23847 case CLOB_BASE:
23848 case DATE_BASE:
23849 case NUMBER_BASE:
23850 case OBJECT:
23851 case OCIROWID:
23852 case OF:
23853 case OID:
23854 case ON:
23855 case OPAQUE:
23856 case OPEN:
23857 case OPERATOR:
23858 case OPTION:
23859 case OR:
23860 case ORDER:
23861 case ORGANIZATION:
23862 case OTHERS:
23863 case OUT:
23864 case OVERRIDING:
23865 case PACKAGE:
23866 case PARTITION:
23867 case PCTFREE:
23868 case PLS_INTEGER:
23869 case POSITIVE:
23870 case POSITIVEN:
23871 case PRAGMA:
23872 case PRESERVE:
23873 case PRIOR:
23874 case PROMPT:
23875 case PRIVATE:
23876 case PROCEDURE:
23877 case PUBLIC:
23878 case RAISE:
23879 case RANGE:
23880 case RAW:
23881 case REAL:
23882 case RECORD:
23883 case REF:
23884 case RELEASE:
23885 case RELIES_ON:
23886 case RENAME:
23887 case RESULT:
23888 case RETURN:
23889 case RETURNING:
23890 case REVERSE:
23891 case ROLLBACK:
23892 case ROW:
23893 case ROWS:
23894 case ROWID:
23895 case ROWNUM:
23896 case ROWTYPE:
23897 case SAVE:
23898 case SAVEPOINT:
23899 case SECOND:
23900 case SELECT:
23901 case SELF:
23902 case SEPARATE:
23903 case SET:
23904 case SHARE:
23905 case SMALLINT:
23906 case SPACE:
23907 case SQL:
23908 case SQLCODE:
23909 case SQLERRM:
23910 case START:
23911 case STATIC:
23912 case STDDEV:
23913 case SUBTYPE:
23914 case SUBSTITUTABLE:
23915 case SUCCESSFUL:
23916 case SUM:
23917 case SYNONYM:
23918 case SYSDATE:
23919 case SYS_REFCURSOR:
23920 case TABLE:
23921 case TEMPORARY:
23922 case THEN:
23923 case TIME:
23924 case TIMESTAMP:
23925 case TIMEZONE_REGION:
23926 case TIMEZONE_ABBR:
23927 case TIMEZONE_MINUTE:
23928 case TIMEZONE_HOUR:
23929 case TO:
23930 case TRANSACTION:
23931 case TRIGGER:
23932 case TRUE:
23933 case TYPE:
23934 case UI:
23935 case UNDER:
23936 case USING:
23937 case WHILE:
23938 case YES:
23939 case SHOW:
23940 case A:
23941 case UPDATE:
23942 case VARCHAR:
23943 case VARCHAR2:
23944 case DOUBLE:
23945 case DEC:
23946 case PRECISION:
23947 case INT:
23948 case NUMERIC:
23949 case SIGNTYPE:
23950 case NCHAR:
23951 case NVARCHAR2:
23952 case STRING:
23953 case UROWID:
23954 case VARRAY:
23955 case VARYING:
23956 case BFILE:
23957 case BLOB:
23958 case CLOB:
23959 case NCLOB:
23960 case YEAR:
23961 case LOCAL:
23962 case WITH:
23963 case ZONE:
23964 case CHARACTER:
23965 case AFTER:
23966 case BEFORE:
23967 case OLD:
23968 case PARENT:
23969 case CC_IF:
23970 case ANALYZE:
23971 case ASSOCIATE:
23972 case AUDIT:
23973 case COMPOUND:
23974 case DATABASE:
23975 case CALL:
23976 case DDL:
23977 case DISASSOCIATE:
23978 case EACH:
23979 case FOLLOWS:
23980 case LOGOFF:
23981 case LOGON:
23982 case NESTED:
23983 case NOAUDIT:
23984 case SCHEMA:
23985 case SERVERERROR:
23986 case SHUTDOWN:
23987 case STARTUP:
23988 case STATEMENT:
23989 case STATISTICS:
23990 case SUSPEND:
23991 case TRUNCATE:
23992 case WRAPPED:
23993 case LIBRARY:
23994 case NAME:
23995 case STRUCT:
23996 case CONTEXT:
23997 case PARAMETERS:
23998 case LENGTH:
23999 case TDO:
24000 case MAXLEN:
24001 case CHARSETID:
24002 case CHARSETFORM:
24003 case ACCEPT:
24004 case ACCESSIBLE:
24005 case COPY:
24006 case DEFINE:
24007 case DISCONNECT:
24008 case HOST:
24009 case PRINT:
24010 case QUIT:
24011 case REMARK:
24012 case UNDEFINE:
24013 case VARIABLE:
24014 case WHENEVER:
24015 case ATTACH:
24016 case CAST:
24017 case TREAT:
24018 case TRIM:
24019 case LEFT:
24020 case RIGHT:
24021 case BOTH:
24022 case EMPTY:
24023 case MULTISET:
24024 case SUBMULTISET:
24025 case LEADING:
24026 case TRAILING:
24027 case CHAR_CS:
24028 case NCHAR_CS:
24029 case DBTIMEZONE:
24030 case SESSIONTIMEZONE:
24031 case AUTHENTICATED:
24032 case LINK:
24033 case SHARED:
24034 case DIRECTORY:
24035 case USER:
24036 case IDENTIFIER:
24037 case QUOTED_LITERAL:
24038 case SQLDATA_CLASS:
24039 case CUSTOMDATUM_CLASS:
24040 case ORADATA_CLASS:
24041 case JAVA_INTERFACE_CLASS:
24042 DeclarativeSection();
24043 jj_consume_token(BEGIN);
24044 label_74:
24045 while (true) {
24046 switch (jj_nt.kind) {
24047 case 5:
24048 case 16:
24049 case 17:
24050 case 21:
24051 case REPLACE:
24052 case DEFINER:
24053 case CURRENT_USER:
24054 case LANGUAGE:
24055 case INLINE:
24056 case ADD:
24057 case AGGREGATE:
24058 case ARRAY:
24059 case AT:
24060 case ATTRIBUTE:
24061 case AUTHID:
24062 case BEGIN:
24063 case BODY:
24064 case BULK:
24065 case BYTE:
24066 case CASCADE:
24067 case CASE:
24068 case CLOSE:
24069 case COALESCE:
24070 case COLLECT:
24071 case COLUMN:
24072 case COMMENT:
24073 case COMMIT:
24074 case CONSTRUCTOR:
24075 case CONTINUE:
24076 case CONVERT:
24077 case CURRENT:
24078 case CURSOR:
24079 case DATA:
24080 case DATE:
24081 case DAY:
24082 case DECLARE:
24083 case DELETE:
24084 case DISABLE:
24085 case EDITIONABLE:
24086 case ELEMENT:
24087 case ENABLE:
24088 case ESCAPE:
24089 case EXCEPT:
24090 case EXCEPTIONS:
24091 case EXECUTE:
24092 case EXIT:
24093 case EXTERNAL:
24094 case EXTENDS:
24095 case EXTRACT:
24096 case FALSE:
24097 case FETCH:
24098 case FINAL:
24099 case FOR:
24100 case FORALL:
24101 case FORCE:
24102 case FUNCTION:
24103 case GLOBAL:
24104 case GOTO:
24105 case HASH:
24106 case HEAP:
24107 case HOUR:
24108 case IF:
24109 case IMMEDIATE:
24110 case INDICES:
24111 case INDEXTYPE:
24112 case INDICATOR:
24113 case INSERT:
24114 case INSTANTIABLE:
24115 case INTERVAL:
24116 case INVALIDATE:
24117 case ISOLATION:
24118 case JAVA:
24119 case LEVEL:
24120 case LIMIT:
24121 case LOCK:
24122 case LOOP:
24123 case MAP:
24124 case MAX:
24125 case MEMBER:
24126 case MERGE:
24127 case MIN:
24128 case MINUTE:
24129 case MLSLABEL:
24130 case MODIFY:
24131 case MOD:
24132 case MONTH:
24133 case NATURAL:
24134 case NEW:
24135 case NEW_DOT:
24136 case NO:
24137 case NONEDITIONABLE:
24138 case NOT:
24139 case NULL:
24140 case NULLIF:
24141 case OBJECT:
24142 case OID:
24143 case OPAQUE:
24144 case OPEN:
24145 case OPERATOR:
24146 case ORGANIZATION:
24147 case OTHERS:
24148 case OVERRIDING:
24149 case PACKAGE:
24150 case PARTITION:
24151 case PIPE:
24152 case PRAGMA:
24153 case PRESERVE:
24154 case PRIVATE:
24155 case PROCEDURE:
24156 case RAISE:
24157 case RANGE:
24158 case RAW:
24159 case REAL:
24160 case RECORD:
24161 case REF:
24162 case RELEASE:
24163 case RELIES_ON:
24164 case RENAME:
24165 case RESULT:
24166 case RETURN:
24167 case RETURNING:
24168 case REVERSE:
24169 case ROLLBACK:
24170 case ROW:
24171 case ROWS:
24172 case ROWID:
24173 case ROWNUM:
24174 case SAVE:
24175 case SAVEPOINT:
24176 case SECOND:
24177 case SELECT:
24178 case SELF:
24179 case SET:
24180 case SPACE:
24181 case SQL:
24182 case SQLCODE:
24183 case SQLERRM:
24184 case STATIC:
24185 case SUBTYPE:
24186 case SUBSTITUTABLE:
24187 case SUCCESSFUL:
24188 case SYSDATE:
24189 case SYS_REFCURSOR:
24190 case TEMPORARY:
24191 case TIME:
24192 case TIMESTAMP:
24193 case TIMEZONE_REGION:
24194 case TIMEZONE_ABBR:
24195 case TIMEZONE_MINUTE:
24196 case TIMEZONE_HOUR:
24197 case TRANSACTION:
24198 case TRUE:
24199 case TYPE:
24200 case UNDER:
24201 case USING:
24202 case WHILE:
24203 case YES:
24204 case SHOW:
24205 case A:
24206 case UPDATE:
24207 case DOUBLE:
24208 case DEC:
24209 case PRECISION:
24210 case INT:
24211 case NUMERIC:
24212 case NCHAR:
24213 case NVARCHAR2:
24214 case STRING:
24215 case UROWID:
24216 case VARRAY:
24217 case VARYING:
24218 case BFILE:
24219 case BLOB:
24220 case CLOB:
24221 case NCLOB:
24222 case YEAR:
24223 case LOCAL:
24224 case WITH:
24225 case ZONE:
24226 case CHARACTER:
24227 case AFTER:
24228 case BEFORE:
24229 case OLD:
24230 case PARENT:
24231 case CC_IF:
24232 case CC_ERROR:
24233 case ANALYZE:
24234 case ASSOCIATE:
24235 case AUDIT:
24236 case COMPOUND:
24237 case DATABASE:
24238 case CALL:
24239 case DDL:
24240 case DISASSOCIATE:
24241 case EACH:
24242 case FOLLOWS:
24243 case LOGOFF:
24244 case LOGON:
24245 case NESTED:
24246 case NOAUDIT:
24247 case SCHEMA:
24248 case SERVERERROR:
24249 case SHUTDOWN:
24250 case STARTUP:
24251 case STATEMENT:
24252 case STATISTICS:
24253 case SUSPEND:
24254 case TRUNCATE:
24255 case WRAPPED:
24256 case LIBRARY:
24257 case NAME:
24258 case STRUCT:
24259 case CONTEXT:
24260 case PARAMETERS:
24261 case LENGTH:
24262 case TDO:
24263 case MAXLEN:
24264 case CHARSETID:
24265 case CHARSETFORM:
24266 case ACCEPT:
24267 case ACCESSIBLE:
24268 case COPY:
24269 case DEFINE:
24270 case DISCONNECT:
24271 case HOST:
24272 case PRINT:
24273 case QUIT:
24274 case REMARK:
24275 case UNDEFINE:
24276 case VARIABLE:
24277 case WHENEVER:
24278 case ATTACH:
24279 case CAST:
24280 case TREAT:
24281 case TRIM:
24282 case LEFT:
24283 case RIGHT:
24284 case BOTH:
24285 case EMPTY:
24286 case MULTISET:
24287 case SUBMULTISET:
24288 case LEADING:
24289 case TRAILING:
24290 case CHAR_CS:
24291 case NCHAR_CS:
24292 case DBTIMEZONE:
24293 case SESSIONTIMEZONE:
24294 case AUTHENTICATED:
24295 case LINK:
24296 case SHARED:
24297 case DIRECTORY:
24298 case USER:
24299 case IDENTIFIER:
24300 case UNSIGNED_NUMERIC_LITERAL:
24301 case CHARACTER_LITERAL:
24302 case STRING_LITERAL:
24303 case QUOTED_LITERAL:
24304 ;
24305 break;
24306 default:
24307 jj_la1[337] = jj_gen;
24308 break label_74;
24309 }
24310 Statement();
24311 }
24312 switch (jj_nt.kind) {
24313 case EXCEPTION:
24314 ExceptionHandler();
24315 break;
24316 default:
24317 jj_la1[338] = jj_gen;
24318 ;
24319 }
24320 jj_consume_token(END);
24321 switch (jj_nt.kind) {
24322 case REPLACE:
24323 case DEFINER:
24324 case CURRENT_USER:
24325 case SERIALLY_REUSABLE:
24326 case RESTRICT_REFERENCES:
24327 case EXCEPTION_INIT:
24328 case AUTONOMOUS_TRANSACTION:
24329 case LANGUAGE:
24330 case INLINE:
24331 case ADD:
24332 case AGGREGATE:
24333 case ALL:
24334 case ALTER:
24335 case AND:
24336 case ANY:
24337 case ARRAY:
24338 case AS:
24339 case ASC:
24340 case AT:
24341 case ATTRIBUTE:
24342 case AUTHID:
24343 case AVG:
24344 case BETWEEN:
24345 case BINARY_INTEGER:
24346 case BODY:
24347 case BOOLEAN:
24348 case BULK:
24349 case BY:
24350 case BYTE:
24351 case CASCADE:
24352 case CASE:
24353 case CHAR:
24354 case CHAR_BASE:
24355 case CHECK:
24356 case CLOSE:
24357 case CLUSTER:
24358 case COALESCE:
24359 case COLLECT:
24360 case COLUMN:
24361 case COMMENT:
24362 case COMMIT:
24363 case COMPRESS:
24364 case CONNECT:
24365 case CONSTANT:
24366 case CONSTRUCTOR:
24367 case CONTINUE:
24368 case CONVERT:
24369 case CREATE:
24370 case CURRENT:
24371 case CURRVAL:
24372 case CURSOR:
24373 case DATA:
24374 case DATE:
24375 case DAY:
24376 case DECLARE:
24377 case DECIMAL:
24378 case _DEFAULT:
24379 case DELETE:
24380 case DESC:
24381 case DISABLE:
24382 case DISTINCT:
24383 case DO:
24384 case DROP:
24385 case EDITIONABLE:
24386 case ELEMENT:
24387 case ELSE:
24388 case ELSIF:
24389 case ENABLE:
24390 case ESCAPE:
24391 case EXCEPT:
24392 case EXCEPTION:
24393 case EXCEPTIONS:
24394 case EXCLUSIVE:
24395 case EXECUTE:
24396 case EXISTS:
24397 case EXIT:
24398 case EXTERNAL:
24399 case EXTENDS:
24400 case EXTRACT:
24401 case FALSE:
24402 case FETCH:
24403 case FINAL:
24404 case FLOAT:
24405 case FOR:
24406 case FORALL:
24407 case FORCE:
24408 case FROM:
24409 case FUNCTION:
24410 case GLOBAL:
24411 case GOTO:
24412 case GROUP:
24413 case HASH:
24414 case HAVING:
24415 case HEAP:
24416 case HOUR:
24417 case IF:
24418 case IMMEDIATE:
24419 case IN:
24420 case INDEX:
24421 case INDICES:
24422 case INDEXTYPE:
24423 case INDICATOR:
24424 case INSERT:
24425 case INSTANTIABLE:
24426 case INTEGER:
24427 case INTERFACE:
24428 case INTERSECT:
24429 case INTERVAL:
24430 case INTO:
24431 case INVALIDATE:
24432 case IS:
24433 case ISOLATION:
24434 case JAVA:
24435 case LEVEL:
24436 case LIKE:
24437 case LIMIT:
24438 case LIMITED:
24439 case LOCK:
24440 case LONG:
24441 case LOOP:
24442 case MAP:
24443 case MAX:
24444 case MEMBER:
24445 case MERGE:
24446 case MIN:
24447 case MINUS:
24448 case MINUTE:
24449 case MLSLABEL:
24450 case MODIFY:
24451 case MOD:
24452 case MODE:
24453 case MONTH:
24454 case NATURAL:
24455 case NATURALN:
24456 case NEW:
24457 case NEXTVAL:
24458 case NO:
24459 case NOCOPY:
24460 case NONEDITIONABLE:
24461 case NOT:
24462 case NOWAIT:
24463 case NULL:
24464 case NULLIF:
24465 case NUMBER:
24466 case BFILE_BASE:
24467 case BLOB_BASE:
24468 case CLOB_BASE:
24469 case DATE_BASE:
24470 case NUMBER_BASE:
24471 case OBJECT:
24472 case OCIROWID:
24473 case OF:
24474 case OID:
24475 case ON:
24476 case OPAQUE:
24477 case OPEN:
24478 case OPERATOR:
24479 case OPTION:
24480 case OR:
24481 case ORDER:
24482 case ORGANIZATION:
24483 case OTHERS:
24484 case OUT:
24485 case OVERRIDING:
24486 case PACKAGE:
24487 case PARTITION:
24488 case PCTFREE:
24489 case PLS_INTEGER:
24490 case POSITIVE:
24491 case POSITIVEN:
24492 case PRESERVE:
24493 case PRIOR:
24494 case PROMPT:
24495 case PRIVATE:
24496 case PROCEDURE:
24497 case PUBLIC:
24498 case RAISE:
24499 case RANGE:
24500 case RAW:
24501 case REAL:
24502 case RECORD:
24503 case REF:
24504 case RELEASE:
24505 case RELIES_ON:
24506 case RENAME:
24507 case RESULT:
24508 case RETURN:
24509 case RETURNING:
24510 case REVERSE:
24511 case ROLLBACK:
24512 case ROW:
24513 case ROWS:
24514 case ROWID:
24515 case ROWNUM:
24516 case ROWTYPE:
24517 case SAVE:
24518 case SAVEPOINT:
24519 case SECOND:
24520 case SELECT:
24521 case SELF:
24522 case SEPARATE:
24523 case SET:
24524 case SHARE:
24525 case SMALLINT:
24526 case SPACE:
24527 case SQL:
24528 case SQLCODE:
24529 case SQLERRM:
24530 case START:
24531 case STATIC:
24532 case STDDEV:
24533 case SUBTYPE:
24534 case SUBSTITUTABLE:
24535 case SUCCESSFUL:
24536 case SUM:
24537 case SYNONYM:
24538 case SYSDATE:
24539 case SYS_REFCURSOR:
24540 case TABLE:
24541 case TEMPORARY:
24542 case THEN:
24543 case TIME:
24544 case TIMESTAMP:
24545 case TIMEZONE_REGION:
24546 case TIMEZONE_ABBR:
24547 case TIMEZONE_MINUTE:
24548 case TIMEZONE_HOUR:
24549 case TO:
24550 case TRANSACTION:
24551 case TRIGGER:
24552 case TRUE:
24553 case TYPE:
24554 case UI:
24555 case UNDER:
24556 case USING:
24557 case WHILE:
24558 case YES:
24559 case SHOW:
24560 case A:
24561 case UPDATE:
24562 case VARCHAR:
24563 case VARCHAR2:
24564 case DOUBLE:
24565 case DEC:
24566 case PRECISION:
24567 case INT:
24568 case NUMERIC:
24569 case SIGNTYPE:
24570 case NCHAR:
24571 case NVARCHAR2:
24572 case STRING:
24573 case UROWID:
24574 case VARRAY:
24575 case VARYING:
24576 case BFILE:
24577 case BLOB:
24578 case CLOB:
24579 case NCLOB:
24580 case YEAR:
24581 case LOCAL:
24582 case WITH:
24583 case ZONE:
24584 case CHARACTER:
24585 case AFTER:
24586 case BEFORE:
24587 case OLD:
24588 case PARENT:
24589 case ANALYZE:
24590 case ASSOCIATE:
24591 case AUDIT:
24592 case COMPOUND:
24593 case DATABASE:
24594 case CALL:
24595 case DDL:
24596 case DISASSOCIATE:
24597 case EACH:
24598 case FOLLOWS:
24599 case LOGOFF:
24600 case LOGON:
24601 case NESTED:
24602 case NOAUDIT:
24603 case SCHEMA:
24604 case SERVERERROR:
24605 case SHUTDOWN:
24606 case STARTUP:
24607 case STATEMENT:
24608 case STATISTICS:
24609 case SUSPEND:
24610 case TRUNCATE:
24611 case WRAPPED:
24612 case LIBRARY:
24613 case NAME:
24614 case STRUCT:
24615 case CONTEXT:
24616 case PARAMETERS:
24617 case LENGTH:
24618 case TDO:
24619 case MAXLEN:
24620 case CHARSETID:
24621 case CHARSETFORM:
24622 case ACCEPT:
24623 case ACCESSIBLE:
24624 case COPY:
24625 case DEFINE:
24626 case DISCONNECT:
24627 case HOST:
24628 case PRINT:
24629 case QUIT:
24630 case REMARK:
24631 case UNDEFINE:
24632 case VARIABLE:
24633 case WHENEVER:
24634 case ATTACH:
24635 case CAST:
24636 case TREAT:
24637 case TRIM:
24638 case LEFT:
24639 case RIGHT:
24640 case BOTH:
24641 case EMPTY:
24642 case MULTISET:
24643 case SUBMULTISET:
24644 case LEADING:
24645 case TRAILING:
24646 case CHAR_CS:
24647 case NCHAR_CS:
24648 case DBTIMEZONE:
24649 case SESSIONTIMEZONE:
24650 case AUTHENTICATED:
24651 case LINK:
24652 case SHARED:
24653 case DIRECTORY:
24654 case USER:
24655 case IDENTIFIER:
24656 case QUOTED_LITERAL:
24657 case SQLDATA_CLASS:
24658 case CUSTOMDATUM_CLASS:
24659 case ORADATA_CLASS:
24660 case JAVA_INTERFACE_CLASS:
24661 ID();
24662 break;
24663 default:
24664 jj_la1[339] = jj_gen;
24665 ;
24666 }
24667 jj_consume_token(4);
24668 break;
24669 default:
24670 jj_la1[340] = jj_gen;
24671 jj_consume_token(-1);
24672 throw new ParseException();
24673 }
24674 break;
24675 default:
24676 jj_la1[341] = jj_gen;
24677 ;
24678 }
24679 jjtree.closeNodeScope(jjtn000, true);
24680 jjtc000 = false;
24681 {if (true) return jjtn000 ;}
24682 } catch (Throwable jjte000) {
24683 if (jjtc000) {
24684 jjtree.clearNodeScope(jjtn000);
24685 jjtc000 = false;
24686 } else {
24687 jjtree.popNode();
24688 }
24689 if (jjte000 instanceof RuntimeException) {
24690 {if (true) throw (RuntimeException)jjte000;}
24691 }
24692 if (jjte000 instanceof ParseException) {
24693 {if (true) throw (ParseException)jjte000;}
24694 }
24695 {if (true) throw (Error)jjte000;}
24696 } finally {
24697 if (jjtc000) {
24698 jjtree.closeNodeScope(jjtn000, true);
24699 }
24700 }
24701 throw new Error("Missing return statement in function");
24702 }
24703
24704 final public ASTTypeSpecification TypeSpecification() throws ParseException {
24705
24706 ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24707 boolean jjtc000 = true;
24708 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24709 try {
24710 switch (jj_nt.kind) {
24711 case CREATE:
24712 jj_consume_token(CREATE);
24713 switch (jj_nt.kind) {
24714 case OR:
24715 jj_consume_token(OR);
24716 jj_consume_token(REPLACE);
24717 break;
24718 default:
24719 jj_la1[342] = jj_gen;
24720 ;
24721 }
24722 switch (jj_nt.kind) {
24723 case EDITIONABLE:
24724 case NONEDITIONABLE:
24725 switch (jj_nt.kind) {
24726 case EDITIONABLE:
24727 jj_consume_token(EDITIONABLE);
24728 break;
24729 case NONEDITIONABLE:
24730 jj_consume_token(NONEDITIONABLE);
24731 break;
24732 default:
24733 jj_la1[343] = jj_gen;
24734 jj_consume_token(-1);
24735 throw new ParseException();
24736 }
24737 break;
24738 default:
24739 jj_la1[344] = jj_gen;
24740 ;
24741 }
24742 break;
24743 default:
24744 jj_la1[345] = jj_gen;
24745 ;
24746 }
24747 jj_consume_token(TYPE);
24748 simpleNode = ObjectNameDeclaration();
24749 switch (jj_nt.kind) {
24750 case FORCE:
24751 jj_consume_token(FORCE);
24752 break;
24753 default:
24754 jj_la1[346] = jj_gen;
24755 ;
24756 }
24757 if (jj_2_63(2)) {
24758 jj_consume_token(OID);
24759 jj_consume_token(STRING_LITERAL);
24760 } else {
24761 ;
24762 }
24763 label_75:
24764 while (true) {
24765 if (jj_2_64(2)) {
24766 ;
24767 } else {
24768 break label_75;
24769 }
24770 switch (jj_nt.kind) {
24771 case AUTHID:
24772 jj_consume_token(AUTHID);
24773 switch (jj_nt.kind) {
24774 case CURRENT_USER:
24775 jj_consume_token(CURRENT_USER);
24776 break;
24777 case DEFINER:
24778 jj_consume_token(DEFINER);
24779 break;
24780 default:
24781 jj_la1[347] = jj_gen;
24782 jj_consume_token(-1);
24783 throw new ParseException();
24784 }
24785 break;
24786 case ACCESSIBLE:
24787 AccessibleByClause();
24788 break;
24789 default:
24790 jj_la1[348] = jj_gen;
24791 jj_consume_token(-1);
24792 throw new ParseException();
24793 }
24794 }
24795 switch (jj_nt.kind) {
24796 case AS:
24797 case IS:
24798 case UNDER:
24799 switch (jj_nt.kind) {
24800 case UNDER:
24801 jj_consume_token(UNDER);
24802 ObjectNameDeclaration();
24803 break;
24804 default:
24805 jj_la1[355] = jj_gen;
24806 if (jj_2_65(2)) {
24807 switch (jj_nt.kind) {
24808 case IS:
24809 jj_consume_token(IS);
24810 break;
24811 case AS:
24812 jj_consume_token(AS);
24813 break;
24814 default:
24815 jj_la1[349] = jj_gen;
24816 jj_consume_token(-1);
24817 throw new ParseException();
24818 }
24819 jj_consume_token(OBJECT);
24820 } else if (jj_2_66(2)) {
24821 switch (jj_nt.kind) {
24822 case IS:
24823 jj_consume_token(IS);
24824 break;
24825 case AS:
24826 jj_consume_token(AS);
24827 break;
24828 default:
24829 jj_la1[350] = jj_gen;
24830 jj_consume_token(-1);
24831 throw new ParseException();
24832 }
24833 jj_consume_token(OPAQUE);
24834 jj_consume_token(VARYING);
24835 jj_consume_token(24);
24836 jj_consume_token(USING);
24837 jj_consume_token(LIBRARY);
24838 switch (jj_nt.kind) {
24839 case IDENTIFIER:
24840 jj_consume_token(IDENTIFIER);
24841 break;
24842 case QUOTED_LITERAL:
24843 jj_consume_token(QUOTED_LITERAL);
24844 break;
24845 case STRING_LITERAL:
24846 StringLiteral();
24847 break;
24848 default:
24849 jj_la1[351] = jj_gen;
24850 jj_consume_token(-1);
24851 throw new ParseException();
24852 }
24853 switch (jj_nt.kind) {
24854 case 3:
24855 jj_consume_token(3);
24856 switch (jj_nt.kind) {
24857 case IDENTIFIER:
24858 jj_consume_token(IDENTIFIER);
24859 break;
24860 case QUOTED_LITERAL:
24861 jj_consume_token(QUOTED_LITERAL);
24862 break;
24863 case STRING_LITERAL:
24864 StringLiteral();
24865 break;
24866 default:
24867 jj_la1[352] = jj_gen;
24868 jj_consume_token(-1);
24869 throw new ParseException();
24870 }
24871 break;
24872 default:
24873 jj_la1[353] = jj_gen;
24874 ;
24875 }
24876 } else if (jj_2_67(2)) {
24877 switch (jj_nt.kind) {
24878 case IS:
24879 jj_consume_token(IS);
24880 break;
24881 case AS:
24882 jj_consume_token(AS);
24883 break;
24884 default:
24885 jj_la1[354] = jj_gen;
24886 jj_consume_token(-1);
24887 throw new ParseException();
24888 }
24889 CollectionTypeName();
24890 jj_consume_token(OF);
24891 Datatype();
24892 } else {
24893 jj_consume_token(-1);
24894 throw new ParseException();
24895 }
24896 }
24897 break;
24898 default:
24899 jj_la1[356] = jj_gen;
24900 ;
24901 }
24902 if (jj_2_68(8)) {
24903 jj_consume_token(EXTERNAL);
24904 jj_consume_token(IDENTIFIER);
24905 jj_consume_token(IDENTIFIER);
24906 jj_consume_token(LANGUAGE);
24907 jj_consume_token(JAVA);
24908 jj_consume_token(USING);
24909 jj_consume_token(IDENTIFIER);
24910 } else {
24911 ;
24912 }
24913 switch (jj_nt.kind) {
24914 case WRAPPED:
24915 WrappedObject();
24916 break;
24917 default:
24918 jj_la1[357] = jj_gen;
24919 ;
24920 }
24921 switch (jj_nt.kind) {
24922 case 5:
24923 jj_consume_token(5);
24924 label_76:
24925 while (true) {
24926 switch (jj_nt.kind) {
24927 case REPLACE:
24928 case DEFINER:
24929 case CURRENT_USER:
24930 case SERIALLY_REUSABLE:
24931 case RESTRICT_REFERENCES:
24932 case EXCEPTION_INIT:
24933 case AUTONOMOUS_TRANSACTION:
24934 case LANGUAGE:
24935 case INLINE:
24936 case ADD:
24937 case AGGREGATE:
24938 case ALL:
24939 case ALTER:
24940 case AND:
24941 case ANY:
24942 case ARRAY:
24943 case AS:
24944 case ASC:
24945 case AT:
24946 case ATTRIBUTE:
24947 case AUTHID:
24948 case AVG:
24949 case BETWEEN:
24950 case BINARY_INTEGER:
24951 case BODY:
24952 case BOOLEAN:
24953 case BULK:
24954 case BY:
24955 case BYTE:
24956 case CASCADE:
24957 case CASE:
24958 case CHAR:
24959 case CHAR_BASE:
24960 case CHECK:
24961 case CLOSE:
24962 case CLUSTER:
24963 case COALESCE:
24964 case COLLECT:
24965 case COLUMN:
24966 case COMMENT:
24967 case COMMIT:
24968 case COMPRESS:
24969 case CONNECT:
24970 case CONSTANT:
24971 case CONSTRUCTOR:
24972 case CONTINUE:
24973 case CONVERT:
24974 case CREATE:
24975 case CURRENT:
24976 case CURRVAL:
24977 case CURSOR:
24978 case DATA:
24979 case DATE:
24980 case DAY:
24981 case DECLARE:
24982 case DECIMAL:
24983 case _DEFAULT:
24984 case DELETE:
24985 case DESC:
24986 case DISABLE:
24987 case DISTINCT:
24988 case DO:
24989 case DROP:
24990 case EDITIONABLE:
24991 case ELEMENT:
24992 case ELSE:
24993 case ELSIF:
24994 case ENABLE:
24995 case ESCAPE:
24996 case EXCEPT:
24997 case EXCEPTION:
24998 case EXCEPTIONS:
24999 case EXCLUSIVE:
25000 case EXECUTE:
25001 case EXISTS:
25002 case EXIT:
25003 case EXTERNAL:
25004 case EXTENDS:
25005 case EXTRACT:
25006 case FALSE:
25007 case FETCH:
25008 case FINAL:
25009 case FLOAT:
25010 case FOR:
25011 case FORALL:
25012 case FORCE:
25013 case FROM:
25014 case FUNCTION:
25015 case GLOBAL:
25016 case GOTO:
25017 case GROUP:
25018 case HASH:
25019 case HAVING:
25020 case HEAP:
25021 case HOUR:
25022 case IF:
25023 case IMMEDIATE:
25024 case IN:
25025 case INDEX:
25026 case INDICES:
25027 case INDEXTYPE:
25028 case INDICATOR:
25029 case INSERT:
25030 case INSTANTIABLE:
25031 case INTEGER:
25032 case INTERFACE:
25033 case INTERSECT:
25034 case INTERVAL:
25035 case INTO:
25036 case INVALIDATE:
25037 case IS:
25038 case ISOLATION:
25039 case JAVA:
25040 case LEVEL:
25041 case LIKE:
25042 case LIMIT:
25043 case LIMITED:
25044 case LOCK:
25045 case LONG:
25046 case LOOP:
25047 case MAP:
25048 case MAX:
25049 case MEMBER:
25050 case MERGE:
25051 case MIN:
25052 case MINUS:
25053 case MINUTE:
25054 case MLSLABEL:
25055 case MODIFY:
25056 case MOD:
25057 case MODE:
25058 case MONTH:
25059 case NATURAL:
25060 case NATURALN:
25061 case NEW:
25062 case NEXTVAL:
25063 case NO:
25064 case NOCOPY:
25065 case NONEDITIONABLE:
25066 case NOT:
25067 case NOWAIT:
25068 case NULL:
25069 case NULLIF:
25070 case NUMBER:
25071 case BFILE_BASE:
25072 case BLOB_BASE:
25073 case CLOB_BASE:
25074 case DATE_BASE:
25075 case NUMBER_BASE:
25076 case OBJECT:
25077 case OCIROWID:
25078 case OF:
25079 case OID:
25080 case ON:
25081 case OPAQUE:
25082 case OPEN:
25083 case OPERATOR:
25084 case OPTION:
25085 case OR:
25086 case ORDER:
25087 case ORGANIZATION:
25088 case OTHERS:
25089 case OUT:
25090 case OVERRIDING:
25091 case PACKAGE:
25092 case PARTITION:
25093 case PCTFREE:
25094 case PLS_INTEGER:
25095 case POSITIVE:
25096 case POSITIVEN:
25097 case PRAGMA:
25098 case PRESERVE:
25099 case PRIOR:
25100 case PROMPT:
25101 case PRIVATE:
25102 case PROCEDURE:
25103 case PUBLIC:
25104 case RAISE:
25105 case RANGE:
25106 case RAW:
25107 case REAL:
25108 case RECORD:
25109 case REF:
25110 case RELEASE:
25111 case RELIES_ON:
25112 case RENAME:
25113 case RESULT:
25114 case RETURN:
25115 case RETURNING:
25116 case REVERSE:
25117 case ROLLBACK:
25118 case ROW:
25119 case ROWS:
25120 case ROWID:
25121 case ROWNUM:
25122 case ROWTYPE:
25123 case SAVE:
25124 case SAVEPOINT:
25125 case SECOND:
25126 case SELECT:
25127 case SELF:
25128 case SEPARATE:
25129 case SET:
25130 case SHARE:
25131 case SMALLINT:
25132 case SPACE:
25133 case SQL:
25134 case SQLCODE:
25135 case SQLERRM:
25136 case START:
25137 case STATIC:
25138 case STDDEV:
25139 case SUBTYPE:
25140 case SUBSTITUTABLE:
25141 case SUCCESSFUL:
25142 case SUM:
25143 case SYNONYM:
25144 case SYSDATE:
25145 case SYS_REFCURSOR:
25146 case TABLE:
25147 case TEMPORARY:
25148 case THEN:
25149 case TIME:
25150 case TIMESTAMP:
25151 case TIMEZONE_REGION:
25152 case TIMEZONE_ABBR:
25153 case TIMEZONE_MINUTE:
25154 case TIMEZONE_HOUR:
25155 case TO:
25156 case TRANSACTION:
25157 case TRIGGER:
25158 case TRUE:
25159 case TYPE:
25160 case UI:
25161 case UNDER:
25162 case USING:
25163 case WHILE:
25164 case YES:
25165 case SHOW:
25166 case A:
25167 case UPDATE:
25168 case VARCHAR:
25169 case VARCHAR2:
25170 case DOUBLE:
25171 case DEC:
25172 case PRECISION:
25173 case INT:
25174 case NUMERIC:
25175 case SIGNTYPE:
25176 case NCHAR:
25177 case NVARCHAR2:
25178 case STRING:
25179 case UROWID:
25180 case VARRAY:
25181 case VARYING:
25182 case BFILE:
25183 case BLOB:
25184 case CLOB:
25185 case NCLOB:
25186 case YEAR:
25187 case LOCAL:
25188 case WITH:
25189 case ZONE:
25190 case CHARACTER:
25191 case AFTER:
25192 case BEFORE:
25193 case OLD:
25194 case PARENT:
25195 case ANALYZE:
25196 case ASSOCIATE:
25197 case AUDIT:
25198 case COMPOUND:
25199 case DATABASE:
25200 case CALL:
25201 case DDL:
25202 case DISASSOCIATE:
25203 case EACH:
25204 case FOLLOWS:
25205 case LOGOFF:
25206 case LOGON:
25207 case NESTED:
25208 case NOAUDIT:
25209 case SCHEMA:
25210 case SERVERERROR:
25211 case SHUTDOWN:
25212 case STARTUP:
25213 case STATEMENT:
25214 case STATISTICS:
25215 case SUSPEND:
25216 case TRUNCATE:
25217 case WRAPPED:
25218 case LIBRARY:
25219 case NAME:
25220 case STRUCT:
25221 case CONTEXT:
25222 case PARAMETERS:
25223 case LENGTH:
25224 case TDO:
25225 case MAXLEN:
25226 case CHARSETID:
25227 case CHARSETFORM:
25228 case ACCEPT:
25229 case ACCESSIBLE:
25230 case COPY:
25231 case DEFINE:
25232 case DISCONNECT:
25233 case HOST:
25234 case PRINT:
25235 case QUIT:
25236 case REMARK:
25237 case UNDEFINE:
25238 case VARIABLE:
25239 case WHENEVER:
25240 case ATTACH:
25241 case CAST:
25242 case TREAT:
25243 case TRIM:
25244 case LEFT:
25245 case RIGHT:
25246 case BOTH:
25247 case EMPTY:
25248 case MULTISET:
25249 case SUBMULTISET:
25250 case LEADING:
25251 case TRAILING:
25252 case CHAR_CS:
25253 case NCHAR_CS:
25254 case DBTIMEZONE:
25255 case SESSIONTIMEZONE:
25256 case AUTHENTICATED:
25257 case LINK:
25258 case SHARED:
25259 case DIRECTORY:
25260 case USER:
25261 case IDENTIFIER:
25262 case QUOTED_LITERAL:
25263 case SQLDATA_CLASS:
25264 case CUSTOMDATUM_CLASS:
25265 case ORADATA_CLASS:
25266 case JAVA_INTERFACE_CLASS:
25267 ;
25268 break;
25269 default:
25270 jj_la1[358] = jj_gen;
25271 break label_76;
25272 }
25273 if (jj_2_69(2)) {
25274 TypeMethod();
25275 } else {
25276 switch (jj_nt.kind) {
25277 case REPLACE:
25278 case DEFINER:
25279 case CURRENT_USER:
25280 case SERIALLY_REUSABLE:
25281 case RESTRICT_REFERENCES:
25282 case EXCEPTION_INIT:
25283 case AUTONOMOUS_TRANSACTION:
25284 case LANGUAGE:
25285 case INLINE:
25286 case ADD:
25287 case AGGREGATE:
25288 case ALL:
25289 case ALTER:
25290 case AND:
25291 case ANY:
25292 case ARRAY:
25293 case AS:
25294 case ASC:
25295 case AT:
25296 case ATTRIBUTE:
25297 case AUTHID:
25298 case AVG:
25299 case BETWEEN:
25300 case BINARY_INTEGER:
25301 case BODY:
25302 case BOOLEAN:
25303 case BULK:
25304 case BY:
25305 case BYTE:
25306 case CASCADE:
25307 case CASE:
25308 case CHAR:
25309 case CHAR_BASE:
25310 case CHECK:
25311 case CLOSE:
25312 case CLUSTER:
25313 case COALESCE:
25314 case COLLECT:
25315 case COLUMN:
25316 case COMMENT:
25317 case COMMIT:
25318 case COMPRESS:
25319 case CONNECT:
25320 case CONSTANT:
25321 case CONSTRUCTOR:
25322 case CONTINUE:
25323 case CONVERT:
25324 case CREATE:
25325 case CURRENT:
25326 case CURRVAL:
25327 case CURSOR:
25328 case DATA:
25329 case DATE:
25330 case DAY:
25331 case DECLARE:
25332 case DECIMAL:
25333 case _DEFAULT:
25334 case DELETE:
25335 case DESC:
25336 case DISABLE:
25337 case DISTINCT:
25338 case DO:
25339 case DROP:
25340 case EDITIONABLE:
25341 case ELEMENT:
25342 case ELSE:
25343 case ELSIF:
25344 case ENABLE:
25345 case ESCAPE:
25346 case EXCEPT:
25347 case EXCEPTION:
25348 case EXCEPTIONS:
25349 case EXCLUSIVE:
25350 case EXECUTE:
25351 case EXISTS:
25352 case EXIT:
25353 case EXTERNAL:
25354 case EXTENDS:
25355 case EXTRACT:
25356 case FALSE:
25357 case FETCH:
25358 case FINAL:
25359 case FLOAT:
25360 case FOR:
25361 case FORALL:
25362 case FORCE:
25363 case FROM:
25364 case FUNCTION:
25365 case GLOBAL:
25366 case GOTO:
25367 case GROUP:
25368 case HASH:
25369 case HAVING:
25370 case HEAP:
25371 case HOUR:
25372 case IF:
25373 case IMMEDIATE:
25374 case IN:
25375 case INDEX:
25376 case INDICES:
25377 case INDEXTYPE:
25378 case INDICATOR:
25379 case INSERT:
25380 case INSTANTIABLE:
25381 case INTEGER:
25382 case INTERFACE:
25383 case INTERSECT:
25384 case INTERVAL:
25385 case INTO:
25386 case INVALIDATE:
25387 case IS:
25388 case ISOLATION:
25389 case JAVA:
25390 case LEVEL:
25391 case LIKE:
25392 case LIMIT:
25393 case LIMITED:
25394 case LOCK:
25395 case LONG:
25396 case LOOP:
25397 case MAP:
25398 case MAX:
25399 case MEMBER:
25400 case MERGE:
25401 case MIN:
25402 case MINUS:
25403 case MINUTE:
25404 case MLSLABEL:
25405 case MODIFY:
25406 case MOD:
25407 case MODE:
25408 case MONTH:
25409 case NATURAL:
25410 case NATURALN:
25411 case NEW:
25412 case NEXTVAL:
25413 case NO:
25414 case NOCOPY:
25415 case NONEDITIONABLE:
25416 case NOT:
25417 case NOWAIT:
25418 case NULL:
25419 case NULLIF:
25420 case NUMBER:
25421 case BFILE_BASE:
25422 case BLOB_BASE:
25423 case CLOB_BASE:
25424 case DATE_BASE:
25425 case NUMBER_BASE:
25426 case OBJECT:
25427 case OCIROWID:
25428 case OF:
25429 case OID:
25430 case ON:
25431 case OPAQUE:
25432 case OPEN:
25433 case OPERATOR:
25434 case OPTION:
25435 case OR:
25436 case ORDER:
25437 case ORGANIZATION:
25438 case OTHERS:
25439 case OUT:
25440 case OVERRIDING:
25441 case PACKAGE:
25442 case PARTITION:
25443 case PCTFREE:
25444 case PLS_INTEGER:
25445 case POSITIVE:
25446 case POSITIVEN:
25447 case PRESERVE:
25448 case PRIOR:
25449 case PROMPT:
25450 case PRIVATE:
25451 case PROCEDURE:
25452 case PUBLIC:
25453 case RAISE:
25454 case RANGE:
25455 case RAW:
25456 case REAL:
25457 case RECORD:
25458 case REF:
25459 case RELEASE:
25460 case RELIES_ON:
25461 case RENAME:
25462 case RESULT:
25463 case RETURN:
25464 case RETURNING:
25465 case REVERSE:
25466 case ROLLBACK:
25467 case ROW:
25468 case ROWS:
25469 case ROWID:
25470 case ROWNUM:
25471 case ROWTYPE:
25472 case SAVE:
25473 case SAVEPOINT:
25474 case SECOND:
25475 case SELECT:
25476 case SELF:
25477 case SEPARATE:
25478 case SET:
25479 case SHARE:
25480 case SMALLINT:
25481 case SPACE:
25482 case SQL:
25483 case SQLCODE:
25484 case SQLERRM:
25485 case START:
25486 case STATIC:
25487 case STDDEV:
25488 case SUBTYPE:
25489 case SUBSTITUTABLE:
25490 case SUCCESSFUL:
25491 case SUM:
25492 case SYNONYM:
25493 case SYSDATE:
25494 case SYS_REFCURSOR:
25495 case TABLE:
25496 case TEMPORARY:
25497 case THEN:
25498 case TIME:
25499 case TIMESTAMP:
25500 case TIMEZONE_REGION:
25501 case TIMEZONE_ABBR:
25502 case TIMEZONE_MINUTE:
25503 case TIMEZONE_HOUR:
25504 case TO:
25505 case TRANSACTION:
25506 case TRIGGER:
25507 case TRUE:
25508 case TYPE:
25509 case UI:
25510 case UNDER:
25511 case USING:
25512 case WHILE:
25513 case YES:
25514 case SHOW:
25515 case A:
25516 case UPDATE:
25517 case VARCHAR:
25518 case VARCHAR2:
25519 case DOUBLE:
25520 case DEC:
25521 case PRECISION:
25522 case INT:
25523 case NUMERIC:
25524 case SIGNTYPE:
25525 case NCHAR:
25526 case NVARCHAR2:
25527 case STRING:
25528 case UROWID:
25529 case VARRAY:
25530 case VARYING:
25531 case BFILE:
25532 case BLOB:
25533 case CLOB:
25534 case NCLOB:
25535 case YEAR:
25536 case LOCAL:
25537 case WITH:
25538 case ZONE:
25539 case CHARACTER:
25540 case AFTER:
25541 case BEFORE:
25542 case OLD:
25543 case PARENT:
25544 case ANALYZE:
25545 case ASSOCIATE:
25546 case AUDIT:
25547 case COMPOUND:
25548 case DATABASE:
25549 case CALL:
25550 case DDL:
25551 case DISASSOCIATE:
25552 case EACH:
25553 case FOLLOWS:
25554 case LOGOFF:
25555 case LOGON:
25556 case NESTED:
25557 case NOAUDIT:
25558 case SCHEMA:
25559 case SERVERERROR:
25560 case SHUTDOWN:
25561 case STARTUP:
25562 case STATEMENT:
25563 case STATISTICS:
25564 case SUSPEND:
25565 case TRUNCATE:
25566 case WRAPPED:
25567 case LIBRARY:
25568 case NAME:
25569 case STRUCT:
25570 case CONTEXT:
25571 case PARAMETERS:
25572 case LENGTH:
25573 case TDO:
25574 case MAXLEN:
25575 case CHARSETID:
25576 case CHARSETFORM:
25577 case ACCEPT:
25578 case ACCESSIBLE:
25579 case COPY:
25580 case DEFINE:
25581 case DISCONNECT:
25582 case HOST:
25583 case PRINT:
25584 case QUIT:
25585 case REMARK:
25586 case UNDEFINE:
25587 case VARIABLE:
25588 case WHENEVER:
25589 case ATTACH:
25590 case CAST:
25591 case TREAT:
25592 case TRIM:
25593 case LEFT:
25594 case RIGHT:
25595 case BOTH:
25596 case EMPTY:
25597 case MULTISET:
25598 case SUBMULTISET:
25599 case LEADING:
25600 case TRAILING:
25601 case CHAR_CS:
25602 case NCHAR_CS:
25603 case DBTIMEZONE:
25604 case SESSIONTIMEZONE:
25605 case AUTHENTICATED:
25606 case LINK:
25607 case SHARED:
25608 case DIRECTORY:
25609 case USER:
25610 case IDENTIFIER:
25611 case QUOTED_LITERAL:
25612 case SQLDATA_CLASS:
25613 case CUSTOMDATUM_CLASS:
25614 case ORADATA_CLASS:
25615 case JAVA_INTERFACE_CLASS:
25616 AttributeDeclaration();
25617 break;
25618 case PRAGMA:
25619 PragmaClause();
25620 break;
25621 default:
25622 jj_la1[359] = jj_gen;
25623 jj_consume_token(-1);
25624 throw new ParseException();
25625 }
25626 }
25627 }
25628 label_77:
25629 while (true) {
25630 switch (jj_nt.kind) {
25631 case 6:
25632 ;
25633 break;
25634 default:
25635 jj_la1[360] = jj_gen;
25636 break label_77;
25637 }
25638 jj_consume_token(6);
25639 switch (jj_nt.kind) {
25640 case CONSTRUCTOR:
25641 case FINAL:
25642 case INSTANTIABLE:
25643 case MAP:
25644 case MEMBER:
25645 case NOT:
25646 case ORDER:
25647 case OVERRIDING:
25648 case STATIC:
25649 TypeMethod();
25650 break;
25651 default:
25652 jj_la1[361] = jj_gen;
25653 if (jj_2_70(2)) {
25654 AttributeDeclaration();
25655 } else {
25656 switch (jj_nt.kind) {
25657 case PRAGMA:
25658 PragmaClause();
25659 break;
25660 default:
25661 jj_la1[362] = jj_gen;
25662 jj_consume_token(-1);
25663 throw new ParseException();
25664 }
25665 }
25666 }
25667 }
25668 jj_consume_token(7);
25669 break;
25670 default:
25671 jj_la1[363] = jj_gen;
25672 ;
25673 }
25674 label_78:
25675 while (true) {
25676 switch (jj_nt.kind) {
25677 case FINAL:
25678 case INSTANTIABLE:
25679 case NOT:
25680 case NULL:
25681 ;
25682 break;
25683 default:
25684 jj_la1[364] = jj_gen;
25685 break label_78;
25686 }
25687 switch (jj_nt.kind) {
25688 case NOT:
25689 jj_consume_token(NOT);
25690 break;
25691 default:
25692 jj_la1[365] = jj_gen;
25693 ;
25694 }
25695 switch (jj_nt.kind) {
25696 case FINAL:
25697 jj_consume_token(FINAL);
25698 break;
25699 case INSTANTIABLE:
25700 jj_consume_token(INSTANTIABLE);
25701 break;
25702 case NULL:
25703 jj_consume_token(NULL);
25704 break;
25705 default:
25706 jj_la1[366] = jj_gen;
25707 jj_consume_token(-1);
25708 throw new ParseException();
25709 }
25710 }
25711 label_79:
25712 while (true) {
25713 switch (jj_nt.kind) {
25714 case ALTER:
25715 ;
25716 break;
25717 default:
25718 jj_la1[367] = jj_gen;
25719 break label_79;
25720 }
25721 AlterTypeSpec();
25722 }
25723 switch (jj_nt.kind) {
25724 case 1:
25725 case 4:
25726 switch (jj_nt.kind) {
25727 case 4:
25728 jj_consume_token(4);
25729 break;
25730 case 1:
25731 jj_consume_token(1);
25732 break;
25733 default:
25734 jj_la1[368] = jj_gen;
25735 jj_consume_token(-1);
25736 throw new ParseException();
25737 }
25738 label_80:
25739 while (true) {
25740 switch (jj_nt.kind) {
25741 case ALTER:
25742 ;
25743 break;
25744 default:
25745 jj_la1[369] = jj_gen;
25746 break label_80;
25747 }
25748 AlterTypeSpec();
25749 switch (jj_nt.kind) {
25750 case 1:
25751 jj_consume_token(1);
25752 break;
25753 case 4:
25754 jj_consume_token(4);
25755 break;
25756 default:
25757 jj_la1[370] = jj_gen;
25758 jj_consume_token(-1);
25759 throw new ParseException();
25760 }
25761 }
25762 break;
25763 default:
25764 jj_la1[371] = jj_gen;
25765 ;
25766 }
25767 jjtree.closeNodeScope(jjtn000, true);
25768 jjtc000 = false;
25769 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
25770 } catch (Throwable jjte000) {
25771 if (jjtc000) {
25772 jjtree.clearNodeScope(jjtn000);
25773 jjtc000 = false;
25774 } else {
25775 jjtree.popNode();
25776 }
25777 if (jjte000 instanceof RuntimeException) {
25778 {if (true) throw (RuntimeException)jjte000;}
25779 }
25780 if (jjte000 instanceof ParseException) {
25781 {if (true) throw (ParseException)jjte000;}
25782 }
25783 {if (true) throw (Error)jjte000;}
25784 } finally {
25785 if (jjtc000) {
25786 jjtree.closeNodeScope(jjtn000, true);
25787 }
25788 }
25789 throw new Error("Missing return statement in function");
25790 }
25791
25792 final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25793
25794 ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25795 boolean jjtc000 = true;
25796 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25797 try {
25798 jj_consume_token(ALTER);
25799 jj_consume_token(TYPE);
25800 simpleNode = QualifiedName();
25801 label_81:
25802 while (true) {
25803 switch (jj_nt.kind) {
25804 case 6:
25805 case ADD:
25806 case DROP:
25807 case MODIFY:
25808 ;
25809 break;
25810 default:
25811 jj_la1[372] = jj_gen;
25812 break label_81;
25813 }
25814 switch (jj_nt.kind) {
25815 case 6:
25816 case ADD:
25817 case MODIFY:
25818 switch (jj_nt.kind) {
25819 case 6:
25820 jj_consume_token(6);
25821 break;
25822 default:
25823 jj_la1[373] = jj_gen;
25824 ;
25825 }
25826 switch (jj_nt.kind) {
25827 case ADD:
25828 jj_consume_token(ADD);
25829 break;
25830 case MODIFY:
25831 jj_consume_token(MODIFY);
25832 break;
25833 default:
25834 jj_la1[374] = jj_gen;
25835 jj_consume_token(-1);
25836 throw new ParseException();
25837 }
25838 label_82:
25839 while (true) {
25840 switch (jj_nt.kind) {
25841 case CONSTRUCTOR:
25842 case FINAL:
25843 case INSTANTIABLE:
25844 case MAP:
25845 case MEMBER:
25846 case NOT:
25847 case ORDER:
25848 case OVERRIDING:
25849 case STATIC:
25850 TypeMethod();
25851 break;
25852 case ATTRIBUTE:
25853 jj_consume_token(ATTRIBUTE);
25854 label_83:
25855 while (true) {
25856 switch (jj_nt.kind) {
25857 case 5:
25858 ;
25859 break;
25860 default:
25861 jj_la1[375] = jj_gen;
25862 break label_83;
25863 }
25864 jj_consume_token(5);
25865 }
25866 AttributeDeclaration();
25867 label_84:
25868 while (true) {
25869 switch (jj_nt.kind) {
25870 case 6:
25871 ;
25872 break;
25873 default:
25874 jj_la1[376] = jj_gen;
25875 break label_84;
25876 }
25877 jj_consume_token(6);
25878 AttributeDeclaration();
25879 }
25880 label_85:
25881 while (true) {
25882 switch (jj_nt.kind) {
25883 case 7:
25884 ;
25885 break;
25886 default:
25887 jj_la1[377] = jj_gen;
25888 break label_85;
25889 }
25890 jj_consume_token(7);
25891 }
25892 break;
25893 case LIMIT:
25894 jj_consume_token(LIMIT);
25895 NumericLiteral();
25896 break;
25897 case ELEMENT:
25898 jj_consume_token(ELEMENT);
25899 jj_consume_token(TYPE);
25900 Datatype();
25901 break;
25902 default:
25903 jj_la1[378] = jj_gen;
25904 jj_consume_token(-1);
25905 throw new ParseException();
25906 }
25907 switch (jj_nt.kind) {
25908 case ATTRIBUTE:
25909 case CONSTRUCTOR:
25910 case ELEMENT:
25911 case FINAL:
25912 case INSTANTIABLE:
25913 case LIMIT:
25914 case MAP:
25915 case MEMBER:
25916 case NOT:
25917 case ORDER:
25918 case OVERRIDING:
25919 case STATIC:
25920 ;
25921 break;
25922 default:
25923 jj_la1[379] = jj_gen;
25924 break label_82;
25925 }
25926 }
25927 break;
25928 case DROP:
25929 jj_consume_token(DROP);
25930 label_86:
25931 while (true) {
25932 switch (jj_nt.kind) {
25933 case ATTRIBUTE:
25934 jj_consume_token(ATTRIBUTE);
25935 label_87:
25936 while (true) {
25937 switch (jj_nt.kind) {
25938 case 5:
25939 ;
25940 break;
25941 default:
25942 jj_la1[380] = jj_gen;
25943 break label_87;
25944 }
25945 jj_consume_token(5);
25946 }
25947 Attribute();
25948 label_88:
25949 while (true) {
25950 switch (jj_nt.kind) {
25951 case 6:
25952 ;
25953 break;
25954 default:
25955 jj_la1[381] = jj_gen;
25956 break label_88;
25957 }
25958 jj_consume_token(6);
25959 Attribute();
25960 }
25961 label_89:
25962 while (true) {
25963 switch (jj_nt.kind) {
25964 case 7:
25965 ;
25966 break;
25967 default:
25968 jj_la1[382] = jj_gen;
25969 break label_89;
25970 }
25971 jj_consume_token(7);
25972 }
25973 break;
25974 case CONSTRUCTOR:
25975 case FINAL:
25976 case INSTANTIABLE:
25977 case MAP:
25978 case MEMBER:
25979 case NOT:
25980 case ORDER:
25981 case OVERRIDING:
25982 case STATIC:
25983 TypeMethod();
25984 break;
25985 default:
25986 jj_la1[383] = jj_gen;
25987 jj_consume_token(-1);
25988 throw new ParseException();
25989 }
25990 switch (jj_nt.kind) {
25991 case ATTRIBUTE:
25992 case CONSTRUCTOR:
25993 case FINAL:
25994 case INSTANTIABLE:
25995 case MAP:
25996 case MEMBER:
25997 case NOT:
25998 case ORDER:
25999 case OVERRIDING:
26000 case STATIC:
26001 ;
26002 break;
26003 default:
26004 jj_la1[384] = jj_gen;
26005 break label_86;
26006 }
26007 }
26008 break;
26009 default:
26010 jj_la1[385] = jj_gen;
26011 jj_consume_token(-1);
26012 throw new ParseException();
26013 }
26014 }
26015 switch (jj_nt.kind) {
26016 case REPLACE:
26017 jj_consume_token(REPLACE);
26018 label_90:
26019 while (true) {
26020 if (jj_2_71(2)) {
26021 ;
26022 } else {
26023 break label_90;
26024 }
26025 switch (jj_nt.kind) {
26026 case AUTHID:
26027 jj_consume_token(AUTHID);
26028 switch (jj_nt.kind) {
26029 case CURRENT_USER:
26030 jj_consume_token(CURRENT_USER);
26031 break;
26032 case DEFINER:
26033 jj_consume_token(DEFINER);
26034 break;
26035 default:
26036 jj_la1[386] = jj_gen;
26037 jj_consume_token(-1);
26038 throw new ParseException();
26039 }
26040 break;
26041 case ACCESSIBLE:
26042 AccessibleByClause();
26043 break;
26044 default:
26045 jj_la1[387] = jj_gen;
26046 jj_consume_token(-1);
26047 throw new ParseException();
26048 }
26049 }
26050 switch (jj_nt.kind) {
26051 case IS:
26052 jj_consume_token(IS);
26053 break;
26054 case AS:
26055 jj_consume_token(AS);
26056 break;
26057 default:
26058 jj_la1[388] = jj_gen;
26059 jj_consume_token(-1);
26060 throw new ParseException();
26061 }
26062 jj_consume_token(OBJECT);
26063 jj_consume_token(5);
26064 if (jj_2_72(2)) {
26065 TypeMethod();
26066 } else {
26067 switch (jj_nt.kind) {
26068 case REPLACE:
26069 case DEFINER:
26070 case CURRENT_USER:
26071 case SERIALLY_REUSABLE:
26072 case RESTRICT_REFERENCES:
26073 case EXCEPTION_INIT:
26074 case AUTONOMOUS_TRANSACTION:
26075 case LANGUAGE:
26076 case INLINE:
26077 case ADD:
26078 case AGGREGATE:
26079 case ALL:
26080 case ALTER:
26081 case AND:
26082 case ANY:
26083 case ARRAY:
26084 case AS:
26085 case ASC:
26086 case AT:
26087 case ATTRIBUTE:
26088 case AUTHID:
26089 case AVG:
26090 case BETWEEN:
26091 case BINARY_INTEGER:
26092 case BODY:
26093 case BOOLEAN:
26094 case BULK:
26095 case BY:
26096 case BYTE:
26097 case CASCADE:
26098 case CASE:
26099 case CHAR:
26100 case CHAR_BASE:
26101 case CHECK:
26102 case CLOSE:
26103 case CLUSTER:
26104 case COALESCE:
26105 case COLLECT:
26106 case COLUMN:
26107 case COMMENT:
26108 case COMMIT:
26109 case COMPRESS:
26110 case CONNECT:
26111 case CONSTANT:
26112 case CONSTRUCTOR:
26113 case CONTINUE:
26114 case CONVERT:
26115 case CREATE:
26116 case CURRENT:
26117 case CURRVAL:
26118 case CURSOR:
26119 case DATA:
26120 case DATE:
26121 case DAY:
26122 case DECLARE:
26123 case DECIMAL:
26124 case _DEFAULT:
26125 case DELETE:
26126 case DESC:
26127 case DISABLE:
26128 case DISTINCT:
26129 case DO:
26130 case DROP:
26131 case EDITIONABLE:
26132 case ELEMENT:
26133 case ELSE:
26134 case ELSIF:
26135 case ENABLE:
26136 case ESCAPE:
26137 case EXCEPT:
26138 case EXCEPTION:
26139 case EXCEPTIONS:
26140 case EXCLUSIVE:
26141 case EXECUTE:
26142 case EXISTS:
26143 case EXIT:
26144 case EXTERNAL:
26145 case EXTENDS:
26146 case EXTRACT:
26147 case FALSE:
26148 case FETCH:
26149 case FINAL:
26150 case FLOAT:
26151 case FOR:
26152 case FORALL:
26153 case FORCE:
26154 case FROM:
26155 case FUNCTION:
26156 case GLOBAL:
26157 case GOTO:
26158 case GROUP:
26159 case HASH:
26160 case HAVING:
26161 case HEAP:
26162 case HOUR:
26163 case IF:
26164 case IMMEDIATE:
26165 case IN:
26166 case INDEX:
26167 case INDICES:
26168 case INDEXTYPE:
26169 case INDICATOR:
26170 case INSERT:
26171 case INSTANTIABLE:
26172 case INTEGER:
26173 case INTERFACE:
26174 case INTERSECT:
26175 case INTERVAL:
26176 case INTO:
26177 case INVALIDATE:
26178 case IS:
26179 case ISOLATION:
26180 case JAVA:
26181 case LEVEL:
26182 case LIKE:
26183 case LIMIT:
26184 case LIMITED:
26185 case LOCK:
26186 case LONG:
26187 case LOOP:
26188 case MAP:
26189 case MAX:
26190 case MEMBER:
26191 case MERGE:
26192 case MIN:
26193 case MINUS:
26194 case MINUTE:
26195 case MLSLABEL:
26196 case MODIFY:
26197 case MOD:
26198 case MODE:
26199 case MONTH:
26200 case NATURAL:
26201 case NATURALN:
26202 case NEW:
26203 case NEXTVAL:
26204 case NO:
26205 case NOCOPY:
26206 case NONEDITIONABLE:
26207 case NOT:
26208 case NOWAIT:
26209 case NULL:
26210 case NULLIF:
26211 case NUMBER:
26212 case BFILE_BASE:
26213 case BLOB_BASE:
26214 case CLOB_BASE:
26215 case DATE_BASE:
26216 case NUMBER_BASE:
26217 case OBJECT:
26218 case OCIROWID:
26219 case OF:
26220 case OID:
26221 case ON:
26222 case OPAQUE:
26223 case OPEN:
26224 case OPERATOR:
26225 case OPTION:
26226 case OR:
26227 case ORDER:
26228 case ORGANIZATION:
26229 case OTHERS:
26230 case OUT:
26231 case OVERRIDING:
26232 case PACKAGE:
26233 case PARTITION:
26234 case PCTFREE:
26235 case PLS_INTEGER:
26236 case POSITIVE:
26237 case POSITIVEN:
26238 case PRESERVE:
26239 case PRIOR:
26240 case PROMPT:
26241 case PRIVATE:
26242 case PROCEDURE:
26243 case PUBLIC:
26244 case RAISE:
26245 case RANGE:
26246 case RAW:
26247 case REAL:
26248 case RECORD:
26249 case REF:
26250 case RELEASE:
26251 case RELIES_ON:
26252 case RENAME:
26253 case RESULT:
26254 case RETURN:
26255 case RETURNING:
26256 case REVERSE:
26257 case ROLLBACK:
26258 case ROW:
26259 case ROWS:
26260 case ROWID:
26261 case ROWNUM:
26262 case ROWTYPE:
26263 case SAVE:
26264 case SAVEPOINT:
26265 case SECOND:
26266 case SELECT:
26267 case SELF:
26268 case SEPARATE:
26269 case SET:
26270 case SHARE:
26271 case SMALLINT:
26272 case SPACE:
26273 case SQL:
26274 case SQLCODE:
26275 case SQLERRM:
26276 case START:
26277 case STATIC:
26278 case STDDEV:
26279 case SUBTYPE:
26280 case SUBSTITUTABLE:
26281 case SUCCESSFUL:
26282 case SUM:
26283 case SYNONYM:
26284 case SYSDATE:
26285 case SYS_REFCURSOR:
26286 case TABLE:
26287 case TEMPORARY:
26288 case THEN:
26289 case TIME:
26290 case TIMESTAMP:
26291 case TIMEZONE_REGION:
26292 case TIMEZONE_ABBR:
26293 case TIMEZONE_MINUTE:
26294 case TIMEZONE_HOUR:
26295 case TO:
26296 case TRANSACTION:
26297 case TRIGGER:
26298 case TRUE:
26299 case TYPE:
26300 case UI:
26301 case UNDER:
26302 case USING:
26303 case WHILE:
26304 case YES:
26305 case SHOW:
26306 case A:
26307 case UPDATE:
26308 case VARCHAR:
26309 case VARCHAR2:
26310 case DOUBLE:
26311 case DEC:
26312 case PRECISION:
26313 case INT:
26314 case NUMERIC:
26315 case SIGNTYPE:
26316 case NCHAR:
26317 case NVARCHAR2:
26318 case STRING:
26319 case UROWID:
26320 case VARRAY:
26321 case VARYING:
26322 case BFILE:
26323 case BLOB:
26324 case CLOB:
26325 case NCLOB:
26326 case YEAR:
26327 case LOCAL:
26328 case WITH:
26329 case ZONE:
26330 case CHARACTER:
26331 case AFTER:
26332 case BEFORE:
26333 case OLD:
26334 case PARENT:
26335 case ANALYZE:
26336 case ASSOCIATE:
26337 case AUDIT:
26338 case COMPOUND:
26339 case DATABASE:
26340 case CALL:
26341 case DDL:
26342 case DISASSOCIATE:
26343 case EACH:
26344 case FOLLOWS:
26345 case LOGOFF:
26346 case LOGON:
26347 case NESTED:
26348 case NOAUDIT:
26349 case SCHEMA:
26350 case SERVERERROR:
26351 case SHUTDOWN:
26352 case STARTUP:
26353 case STATEMENT:
26354 case STATISTICS:
26355 case SUSPEND:
26356 case TRUNCATE:
26357 case WRAPPED:
26358 case LIBRARY:
26359 case NAME:
26360 case STRUCT:
26361 case CONTEXT:
26362 case PARAMETERS:
26363 case LENGTH:
26364 case TDO:
26365 case MAXLEN:
26366 case CHARSETID:
26367 case CHARSETFORM:
26368 case ACCEPT:
26369 case ACCESSIBLE:
26370 case COPY:
26371 case DEFINE:
26372 case DISCONNECT:
26373 case HOST:
26374 case PRINT:
26375 case QUIT:
26376 case REMARK:
26377 case UNDEFINE:
26378 case VARIABLE:
26379 case WHENEVER:
26380 case ATTACH:
26381 case CAST:
26382 case TREAT:
26383 case TRIM:
26384 case LEFT:
26385 case RIGHT:
26386 case BOTH:
26387 case EMPTY:
26388 case MULTISET:
26389 case SUBMULTISET:
26390 case LEADING:
26391 case TRAILING:
26392 case CHAR_CS:
26393 case NCHAR_CS:
26394 case DBTIMEZONE:
26395 case SESSIONTIMEZONE:
26396 case AUTHENTICATED:
26397 case LINK:
26398 case SHARED:
26399 case DIRECTORY:
26400 case USER:
26401 case IDENTIFIER:
26402 case QUOTED_LITERAL:
26403 case SQLDATA_CLASS:
26404 case CUSTOMDATUM_CLASS:
26405 case ORADATA_CLASS:
26406 case JAVA_INTERFACE_CLASS:
26407 AttributeDeclaration();
26408 break;
26409 default:
26410 jj_la1[389] = jj_gen;
26411 jj_consume_token(-1);
26412 throw new ParseException();
26413 }
26414 }
26415 label_91:
26416 while (true) {
26417 switch (jj_nt.kind) {
26418 case 6:
26419 ;
26420 break;
26421 default:
26422 jj_la1[390] = jj_gen;
26423 break label_91;
26424 }
26425 jj_consume_token(6);
26426 if (jj_2_73(2)) {
26427 TypeMethod();
26428 } else {
26429 switch (jj_nt.kind) {
26430 case REPLACE:
26431 case DEFINER:
26432 case CURRENT_USER:
26433 case SERIALLY_REUSABLE:
26434 case RESTRICT_REFERENCES:
26435 case EXCEPTION_INIT:
26436 case AUTONOMOUS_TRANSACTION:
26437 case LANGUAGE:
26438 case INLINE:
26439 case ADD:
26440 case AGGREGATE:
26441 case ALL:
26442 case ALTER:
26443 case AND:
26444 case ANY:
26445 case ARRAY:
26446 case AS:
26447 case ASC:
26448 case AT:
26449 case ATTRIBUTE:
26450 case AUTHID:
26451 case AVG:
26452 case BETWEEN:
26453 case BINARY_INTEGER:
26454 case BODY:
26455 case BOOLEAN:
26456 case BULK:
26457 case BY:
26458 case BYTE:
26459 case CASCADE:
26460 case CASE:
26461 case CHAR:
26462 case CHAR_BASE:
26463 case CHECK:
26464 case CLOSE:
26465 case CLUSTER:
26466 case COALESCE:
26467 case COLLECT:
26468 case COLUMN:
26469 case COMMENT:
26470 case COMMIT:
26471 case COMPRESS:
26472 case CONNECT:
26473 case CONSTANT:
26474 case CONSTRUCTOR:
26475 case CONTINUE:
26476 case CONVERT:
26477 case CREATE:
26478 case CURRENT:
26479 case CURRVAL:
26480 case CURSOR:
26481 case DATA:
26482 case DATE:
26483 case DAY:
26484 case DECLARE:
26485 case DECIMAL:
26486 case _DEFAULT:
26487 case DELETE:
26488 case DESC:
26489 case DISABLE:
26490 case DISTINCT:
26491 case DO:
26492 case DROP:
26493 case EDITIONABLE:
26494 case ELEMENT:
26495 case ELSE:
26496 case ELSIF:
26497 case ENABLE:
26498 case ESCAPE:
26499 case EXCEPT:
26500 case EXCEPTION:
26501 case EXCEPTIONS:
26502 case EXCLUSIVE:
26503 case EXECUTE:
26504 case EXISTS:
26505 case EXIT:
26506 case EXTERNAL:
26507 case EXTENDS:
26508 case EXTRACT:
26509 case FALSE:
26510 case FETCH:
26511 case FINAL:
26512 case FLOAT:
26513 case FOR:
26514 case FORALL:
26515 case FORCE:
26516 case FROM:
26517 case FUNCTION:
26518 case GLOBAL:
26519 case GOTO:
26520 case GROUP:
26521 case HASH:
26522 case HAVING:
26523 case HEAP:
26524 case HOUR:
26525 case IF:
26526 case IMMEDIATE:
26527 case IN:
26528 case INDEX:
26529 case INDICES:
26530 case INDEXTYPE:
26531 case INDICATOR:
26532 case INSERT:
26533 case INSTANTIABLE:
26534 case INTEGER:
26535 case INTERFACE:
26536 case INTERSECT:
26537 case INTERVAL:
26538 case INTO:
26539 case INVALIDATE:
26540 case IS:
26541 case ISOLATION:
26542 case JAVA:
26543 case LEVEL:
26544 case LIKE:
26545 case LIMIT:
26546 case LIMITED:
26547 case LOCK:
26548 case LONG:
26549 case LOOP:
26550 case MAP:
26551 case MAX:
26552 case MEMBER:
26553 case MERGE:
26554 case MIN:
26555 case MINUS:
26556 case MINUTE:
26557 case MLSLABEL:
26558 case MODIFY:
26559 case MOD:
26560 case MODE:
26561 case MONTH:
26562 case NATURAL:
26563 case NATURALN:
26564 case NEW:
26565 case NEXTVAL:
26566 case NO:
26567 case NOCOPY:
26568 case NONEDITIONABLE:
26569 case NOT:
26570 case NOWAIT:
26571 case NULL:
26572 case NULLIF:
26573 case NUMBER:
26574 case BFILE_BASE:
26575 case BLOB_BASE:
26576 case CLOB_BASE:
26577 case DATE_BASE:
26578 case NUMBER_BASE:
26579 case OBJECT:
26580 case OCIROWID:
26581 case OF:
26582 case OID:
26583 case ON:
26584 case OPAQUE:
26585 case OPEN:
26586 case OPERATOR:
26587 case OPTION:
26588 case OR:
26589 case ORDER:
26590 case ORGANIZATION:
26591 case OTHERS:
26592 case OUT:
26593 case OVERRIDING:
26594 case PACKAGE:
26595 case PARTITION:
26596 case PCTFREE:
26597 case PLS_INTEGER:
26598 case POSITIVE:
26599 case POSITIVEN:
26600 case PRESERVE:
26601 case PRIOR:
26602 case PROMPT:
26603 case PRIVATE:
26604 case PROCEDURE:
26605 case PUBLIC:
26606 case RAISE:
26607 case RANGE:
26608 case RAW:
26609 case REAL:
26610 case RECORD:
26611 case REF:
26612 case RELEASE:
26613 case RELIES_ON:
26614 case RENAME:
26615 case RESULT:
26616 case RETURN:
26617 case RETURNING:
26618 case REVERSE:
26619 case ROLLBACK:
26620 case ROW:
26621 case ROWS:
26622 case ROWID:
26623 case ROWNUM:
26624 case ROWTYPE:
26625 case SAVE:
26626 case SAVEPOINT:
26627 case SECOND:
26628 case SELECT:
26629 case SELF:
26630 case SEPARATE:
26631 case SET:
26632 case SHARE:
26633 case SMALLINT:
26634 case SPACE:
26635 case SQL:
26636 case SQLCODE:
26637 case SQLERRM:
26638 case START:
26639 case STATIC:
26640 case STDDEV:
26641 case SUBTYPE:
26642 case SUBSTITUTABLE:
26643 case SUCCESSFUL:
26644 case SUM:
26645 case SYNONYM:
26646 case SYSDATE:
26647 case SYS_REFCURSOR:
26648 case TABLE:
26649 case TEMPORARY:
26650 case THEN:
26651 case TIME:
26652 case TIMESTAMP:
26653 case TIMEZONE_REGION:
26654 case TIMEZONE_ABBR:
26655 case TIMEZONE_MINUTE:
26656 case TIMEZONE_HOUR:
26657 case TO:
26658 case TRANSACTION:
26659 case TRIGGER:
26660 case TRUE:
26661 case TYPE:
26662 case UI:
26663 case UNDER:
26664 case USING:
26665 case WHILE:
26666 case YES:
26667 case SHOW:
26668 case A:
26669 case UPDATE:
26670 case VARCHAR:
26671 case VARCHAR2:
26672 case DOUBLE:
26673 case DEC:
26674 case PRECISION:
26675 case INT:
26676 case NUMERIC:
26677 case SIGNTYPE:
26678 case NCHAR:
26679 case NVARCHAR2:
26680 case STRING:
26681 case UROWID:
26682 case VARRAY:
26683 case VARYING:
26684 case BFILE:
26685 case BLOB:
26686 case CLOB:
26687 case NCLOB:
26688 case YEAR:
26689 case LOCAL:
26690 case WITH:
26691 case ZONE:
26692 case CHARACTER:
26693 case AFTER:
26694 case BEFORE:
26695 case OLD:
26696 case PARENT:
26697 case ANALYZE:
26698 case ASSOCIATE:
26699 case AUDIT:
26700 case COMPOUND:
26701 case DATABASE:
26702 case CALL:
26703 case DDL:
26704 case DISASSOCIATE:
26705 case EACH:
26706 case FOLLOWS:
26707 case LOGOFF:
26708 case LOGON:
26709 case NESTED:
26710 case NOAUDIT:
26711 case SCHEMA:
26712 case SERVERERROR:
26713 case SHUTDOWN:
26714 case STARTUP:
26715 case STATEMENT:
26716 case STATISTICS:
26717 case SUSPEND:
26718 case TRUNCATE:
26719 case WRAPPED:
26720 case LIBRARY:
26721 case NAME:
26722 case STRUCT:
26723 case CONTEXT:
26724 case PARAMETERS:
26725 case LENGTH:
26726 case TDO:
26727 case MAXLEN:
26728 case CHARSETID:
26729 case CHARSETFORM:
26730 case ACCEPT:
26731 case ACCESSIBLE:
26732 case COPY:
26733 case DEFINE:
26734 case DISCONNECT:
26735 case HOST:
26736 case PRINT:
26737 case QUIT:
26738 case REMARK:
26739 case UNDEFINE:
26740 case VARIABLE:
26741 case WHENEVER:
26742 case ATTACH:
26743 case CAST:
26744 case TREAT:
26745 case TRIM:
26746 case LEFT:
26747 case RIGHT:
26748 case BOTH:
26749 case EMPTY:
26750 case MULTISET:
26751 case SUBMULTISET:
26752 case LEADING:
26753 case TRAILING:
26754 case CHAR_CS:
26755 case NCHAR_CS:
26756 case DBTIMEZONE:
26757 case SESSIONTIMEZONE:
26758 case AUTHENTICATED:
26759 case LINK:
26760 case SHARED:
26761 case DIRECTORY:
26762 case USER:
26763 case IDENTIFIER:
26764 case QUOTED_LITERAL:
26765 case SQLDATA_CLASS:
26766 case CUSTOMDATUM_CLASS:
26767 case ORADATA_CLASS:
26768 case JAVA_INTERFACE_CLASS:
26769 AttributeDeclaration();
26770 break;
26771 default:
26772 jj_la1[391] = jj_gen;
26773 jj_consume_token(-1);
26774 throw new ParseException();
26775 }
26776 }
26777 }
26778 jj_consume_token(7);
26779 break;
26780 default:
26781 jj_la1[392] = jj_gen;
26782 ;
26783 }
26784 label_92:
26785 while (true) {
26786 switch (jj_nt.kind) {
26787 case FINAL:
26788 case INSTANTIABLE:
26789 case NOT:
26790 case NULL:
26791 ;
26792 break;
26793 default:
26794 jj_la1[393] = jj_gen;
26795 break label_92;
26796 }
26797 switch (jj_nt.kind) {
26798 case NOT:
26799 jj_consume_token(NOT);
26800 break;
26801 default:
26802 jj_la1[394] = jj_gen;
26803 ;
26804 }
26805 switch (jj_nt.kind) {
26806 case FINAL:
26807 jj_consume_token(FINAL);
26808 break;
26809 case INSTANTIABLE:
26810 jj_consume_token(INSTANTIABLE);
26811 break;
26812 case NULL:
26813 jj_consume_token(NULL);
26814 break;
26815 default:
26816 jj_la1[395] = jj_gen;
26817 jj_consume_token(-1);
26818 throw new ParseException();
26819 }
26820 }
26821 switch (jj_nt.kind) {
26822 case CASCADE:
26823 case INVALIDATE:
26824 switch (jj_nt.kind) {
26825 case INVALIDATE:
26826 jj_consume_token(INVALIDATE);
26827 break;
26828 case CASCADE:
26829 jj_consume_token(CASCADE);
26830 label_93:
26831 while (true) {
26832 switch (jj_nt.kind) {
26833 case CONVERT:
26834 case INCLUDING:
26835 case NOT:
26836 ;
26837 break;
26838 default:
26839 jj_la1[396] = jj_gen;
26840 break label_93;
26841 }
26842 switch (jj_nt.kind) {
26843 case INCLUDING:
26844 case NOT:
26845 switch (jj_nt.kind) {
26846 case NOT:
26847 jj_consume_token(NOT);
26848 break;
26849 default:
26850 jj_la1[397] = jj_gen;
26851 ;
26852 }
26853 jj_consume_token(INCLUDING);
26854 jj_consume_token(TABLE);
26855 jj_consume_token(DATA);
26856 break;
26857 case CONVERT:
26858 jj_consume_token(CONVERT);
26859 jj_consume_token(TO);
26860 jj_consume_token(SUBSTITUTABLE);
26861 break;
26862 default:
26863 jj_la1[398] = jj_gen;
26864 jj_consume_token(-1);
26865 throw new ParseException();
26866 }
26867 }
26868 switch (jj_nt.kind) {
26869 case EXCEPTIONS:
26870 case FORCE:
26871 switch (jj_nt.kind) {
26872 case FORCE:
26873 jj_consume_token(FORCE);
26874 break;
26875 default:
26876 jj_la1[399] = jj_gen;
26877 ;
26878 }
26879 jj_consume_token(EXCEPTIONS);
26880 jj_consume_token(INTO);
26881 QualifiedName();
26882 break;
26883 default:
26884 jj_la1[400] = jj_gen;
26885 ;
26886 }
26887 break;
26888 default:
26889 jj_la1[401] = jj_gen;
26890 jj_consume_token(-1);
26891 throw new ParseException();
26892 }
26893 break;
26894 default:
26895 jj_la1[402] = jj_gen;
26896 ;
26897 }
26898 jjtree.closeNodeScope(jjtn000, true);
26899 jjtc000 = false;
26900 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26901 } catch (Throwable jjte000) {
26902 if (jjtc000) {
26903 jjtree.clearNodeScope(jjtn000);
26904 jjtc000 = false;
26905 } else {
26906 jjtree.popNode();
26907 }
26908 if (jjte000 instanceof RuntimeException) {
26909 {if (true) throw (RuntimeException)jjte000;}
26910 }
26911 if (jjte000 instanceof ParseException) {
26912 {if (true) throw (ParseException)jjte000;}
26913 }
26914 {if (true) throw (Error)jjte000;}
26915 } finally {
26916 if (jjtc000) {
26917 jjtree.closeNodeScope(jjtn000, true);
26918 }
26919 }
26920 throw new Error("Missing return statement in function");
26921 }
26922
26923
26924
26925
26926
26927
26928
26929
26930
26931
26932
26933
26934
26935
26936
26937
26938
26939
26940
26941
26942
26943
26944
26945
26946
26947
26948
26949
26950
26951 final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26952
26953 ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26954 boolean jjtc000 = true;
26955 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26956 try {
26957 simpleNode = ID();
26958 Datatype();
26959 jjtree.closeNodeScope(jjtn000, true);
26960 jjtc000 = false;
26961 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26962 } catch (Throwable jjte000) {
26963 if (jjtc000) {
26964 jjtree.clearNodeScope(jjtn000);
26965 jjtc000 = false;
26966 } else {
26967 jjtree.popNode();
26968 }
26969 if (jjte000 instanceof RuntimeException) {
26970 {if (true) throw (RuntimeException)jjte000;}
26971 }
26972 if (jjte000 instanceof ParseException) {
26973 {if (true) throw (ParseException)jjte000;}
26974 }
26975 {if (true) throw (Error)jjte000;}
26976 } finally {
26977 if (jjtc000) {
26978 jjtree.closeNodeScope(jjtn000, true);
26979 }
26980 }
26981 throw new Error("Missing return statement in function");
26982 }
26983
26984 final public ASTAttribute Attribute() throws ParseException {
26985
26986 ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26987 boolean jjtc000 = true;
26988 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26989 try {
26990 simpleNode = ID();
26991 jjtree.closeNodeScope(jjtn000, true);
26992 jjtc000 = false;
26993 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26994 } catch (Throwable jjte000) {
26995 if (jjtc000) {
26996 jjtree.clearNodeScope(jjtn000);
26997 jjtc000 = false;
26998 } else {
26999 jjtree.popNode();
27000 }
27001 if (jjte000 instanceof RuntimeException) {
27002 {if (true) throw (RuntimeException)jjte000;}
27003 }
27004 if (jjte000 instanceof ParseException) {
27005 {if (true) throw (ParseException)jjte000;}
27006 }
27007 {if (true) throw (Error)jjte000;}
27008 } finally {
27009 if (jjtc000) {
27010 jjtree.closeNodeScope(jjtn000, true);
27011 }
27012 }
27013 throw new Error("Missing return statement in function");
27014 }
27015
27016
27017
27018
27019 final public ASTPragmaClause PragmaClause() throws ParseException {
27020
27021 ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
27022 boolean jjtc000 = true;
27023 jjtree.openNodeScope(jjtn000);
27024 try {
27025 jj_consume_token(PRAGMA);
27026 switch (jj_nt.kind) {
27027 case SERIALLY_REUSABLE:
27028 jj_consume_token(SERIALLY_REUSABLE);
27029 break;
27030 case AUTONOMOUS_TRANSACTION:
27031 jj_consume_token(AUTONOMOUS_TRANSACTION);
27032 break;
27033 case RESTRICT_REFERENCES:
27034 jj_consume_token(RESTRICT_REFERENCES);
27035 jj_consume_token(5);
27036 ID();
27037 label_94:
27038 while (true) {
27039 jj_consume_token(6);
27040 switch (jj_nt.kind) {
27041 case REPLACE:
27042 case DEFINER:
27043 case CURRENT_USER:
27044 case SERIALLY_REUSABLE:
27045 case RESTRICT_REFERENCES:
27046 case EXCEPTION_INIT:
27047 case AUTONOMOUS_TRANSACTION:
27048 case LANGUAGE:
27049 case INLINE:
27050 case ADD:
27051 case AGGREGATE:
27052 case ALL:
27053 case ALTER:
27054 case AND:
27055 case ANY:
27056 case ARRAY:
27057 case AS:
27058 case ASC:
27059 case AT:
27060 case ATTRIBUTE:
27061 case AUTHID:
27062 case AVG:
27063 case BETWEEN:
27064 case BINARY_INTEGER:
27065 case BODY:
27066 case BOOLEAN:
27067 case BULK:
27068 case BY:
27069 case BYTE:
27070 case CASCADE:
27071 case CASE:
27072 case CHAR:
27073 case CHAR_BASE:
27074 case CHECK:
27075 case CLOSE:
27076 case CLUSTER:
27077 case COALESCE:
27078 case COLLECT:
27079 case COLUMN:
27080 case COMMENT:
27081 case COMMIT:
27082 case COMPRESS:
27083 case CONNECT:
27084 case CONSTANT:
27085 case CONSTRUCTOR:
27086 case CONTINUE:
27087 case CONVERT:
27088 case CREATE:
27089 case CURRENT:
27090 case CURRVAL:
27091 case CURSOR:
27092 case DATA:
27093 case DATE:
27094 case DAY:
27095 case DECLARE:
27096 case DECIMAL:
27097 case _DEFAULT:
27098 case DELETE:
27099 case DESC:
27100 case DISABLE:
27101 case DISTINCT:
27102 case DO:
27103 case DROP:
27104 case EDITIONABLE:
27105 case ELEMENT:
27106 case ELSE:
27107 case ELSIF:
27108 case ENABLE:
27109 case ESCAPE:
27110 case EXCEPT:
27111 case EXCEPTION:
27112 case EXCEPTIONS:
27113 case EXCLUSIVE:
27114 case EXECUTE:
27115 case EXISTS:
27116 case EXIT:
27117 case EXTERNAL:
27118 case EXTENDS:
27119 case EXTRACT:
27120 case FALSE:
27121 case FETCH:
27122 case FINAL:
27123 case FLOAT:
27124 case FOR:
27125 case FORALL:
27126 case FORCE:
27127 case FROM:
27128 case FUNCTION:
27129 case GLOBAL:
27130 case GOTO:
27131 case GROUP:
27132 case HASH:
27133 case HAVING:
27134 case HEAP:
27135 case HOUR:
27136 case IF:
27137 case IMMEDIATE:
27138 case IN:
27139 case INDEX:
27140 case INDICES:
27141 case INDEXTYPE:
27142 case INDICATOR:
27143 case INSERT:
27144 case INSTANTIABLE:
27145 case INTEGER:
27146 case INTERFACE:
27147 case INTERSECT:
27148 case INTERVAL:
27149 case INTO:
27150 case INVALIDATE:
27151 case IS:
27152 case ISOLATION:
27153 case JAVA:
27154 case LEVEL:
27155 case LIKE:
27156 case LIMIT:
27157 case LIMITED:
27158 case LOCK:
27159 case LONG:
27160 case LOOP:
27161 case MAP:
27162 case MAX:
27163 case MEMBER:
27164 case MERGE:
27165 case MIN:
27166 case MINUS:
27167 case MINUTE:
27168 case MLSLABEL:
27169 case MODIFY:
27170 case MOD:
27171 case MODE:
27172 case MONTH:
27173 case NATURAL:
27174 case NATURALN:
27175 case NEW:
27176 case NEXTVAL:
27177 case NO:
27178 case NOCOPY:
27179 case NONEDITIONABLE:
27180 case NOT:
27181 case NOWAIT:
27182 case NULL:
27183 case NULLIF:
27184 case NUMBER:
27185 case BFILE_BASE:
27186 case BLOB_BASE:
27187 case CLOB_BASE:
27188 case DATE_BASE:
27189 case NUMBER_BASE:
27190 case OBJECT:
27191 case OCIROWID:
27192 case OF:
27193 case OID:
27194 case ON:
27195 case OPAQUE:
27196 case OPEN:
27197 case OPERATOR:
27198 case OPTION:
27199 case OR:
27200 case ORDER:
27201 case ORGANIZATION:
27202 case OTHERS:
27203 case OUT:
27204 case OVERRIDING:
27205 case PACKAGE:
27206 case PARTITION:
27207 case PCTFREE:
27208 case PLS_INTEGER:
27209 case POSITIVE:
27210 case POSITIVEN:
27211 case PRESERVE:
27212 case PRIOR:
27213 case PROMPT:
27214 case PRIVATE:
27215 case PROCEDURE:
27216 case PUBLIC:
27217 case RAISE:
27218 case RANGE:
27219 case RAW:
27220 case REAL:
27221 case RECORD:
27222 case REF:
27223 case RELEASE:
27224 case RELIES_ON:
27225 case RENAME:
27226 case RESULT:
27227 case RETURN:
27228 case RETURNING:
27229 case REVERSE:
27230 case ROLLBACK:
27231 case ROW:
27232 case ROWS:
27233 case ROWID:
27234 case ROWNUM:
27235 case ROWTYPE:
27236 case SAVE:
27237 case SAVEPOINT:
27238 case SECOND:
27239 case SELECT:
27240 case SELF:
27241 case SEPARATE:
27242 case SET:
27243 case SHARE:
27244 case SMALLINT:
27245 case SPACE:
27246 case SQL:
27247 case SQLCODE:
27248 case SQLERRM:
27249 case START:
27250 case STATIC:
27251 case STDDEV:
27252 case SUBTYPE:
27253 case SUBSTITUTABLE:
27254 case SUCCESSFUL:
27255 case SUM:
27256 case SYNONYM:
27257 case SYSDATE:
27258 case SYS_REFCURSOR:
27259 case TABLE:
27260 case TEMPORARY:
27261 case THEN:
27262 case TIME:
27263 case TIMESTAMP:
27264 case TIMEZONE_REGION:
27265 case TIMEZONE_ABBR:
27266 case TIMEZONE_MINUTE:
27267 case TIMEZONE_HOUR:
27268 case TO:
27269 case TRANSACTION:
27270 case TRIGGER:
27271 case TRUE:
27272 case TYPE:
27273 case UI:
27274 case UNDER:
27275 case USING:
27276 case WHILE:
27277 case YES:
27278 case SHOW:
27279 case A:
27280 case UPDATE:
27281 case VARCHAR:
27282 case VARCHAR2:
27283 case DOUBLE:
27284 case DEC:
27285 case PRECISION:
27286 case INT:
27287 case NUMERIC:
27288 case SIGNTYPE:
27289 case NCHAR:
27290 case NVARCHAR2:
27291 case STRING:
27292 case UROWID:
27293 case VARRAY:
27294 case VARYING:
27295 case BFILE:
27296 case BLOB:
27297 case CLOB:
27298 case NCLOB:
27299 case YEAR:
27300 case LOCAL:
27301 case WITH:
27302 case ZONE:
27303 case CHARACTER:
27304 case AFTER:
27305 case BEFORE:
27306 case OLD:
27307 case PARENT:
27308 case ANALYZE:
27309 case ASSOCIATE:
27310 case AUDIT:
27311 case COMPOUND:
27312 case DATABASE:
27313 case CALL:
27314 case DDL:
27315 case DISASSOCIATE:
27316 case EACH:
27317 case FOLLOWS:
27318 case LOGOFF:
27319 case LOGON:
27320 case NESTED:
27321 case NOAUDIT:
27322 case SCHEMA:
27323 case SERVERERROR:
27324 case SHUTDOWN:
27325 case STARTUP:
27326 case STATEMENT:
27327 case STATISTICS:
27328 case SUSPEND:
27329 case TRUNCATE:
27330 case WRAPPED:
27331 case LIBRARY:
27332 case NAME:
27333 case STRUCT:
27334 case CONTEXT:
27335 case PARAMETERS:
27336 case LENGTH:
27337 case TDO:
27338 case MAXLEN:
27339 case CHARSETID:
27340 case CHARSETFORM:
27341 case ACCEPT:
27342 case ACCESSIBLE:
27343 case COPY:
27344 case DEFINE:
27345 case DISCONNECT:
27346 case HOST:
27347 case PRINT:
27348 case QUIT:
27349 case REMARK:
27350 case UNDEFINE:
27351 case VARIABLE:
27352 case WHENEVER:
27353 case ATTACH:
27354 case CAST:
27355 case TREAT:
27356 case TRIM:
27357 case LEFT:
27358 case RIGHT:
27359 case BOTH:
27360 case EMPTY:
27361 case MULTISET:
27362 case SUBMULTISET:
27363 case LEADING:
27364 case TRAILING:
27365 case CHAR_CS:
27366 case NCHAR_CS:
27367 case DBTIMEZONE:
27368 case SESSIONTIMEZONE:
27369 case AUTHENTICATED:
27370 case LINK:
27371 case SHARED:
27372 case DIRECTORY:
27373 case USER:
27374 case IDENTIFIER:
27375 case QUOTED_LITERAL:
27376 case SQLDATA_CLASS:
27377 case CUSTOMDATUM_CLASS:
27378 case ORADATA_CLASS:
27379 case JAVA_INTERFACE_CLASS:
27380 ID();
27381 break;
27382 case STRING_LITERAL:
27383 StringLiteral();
27384 break;
27385 default:
27386 jj_la1[403] = jj_gen;
27387 jj_consume_token(-1);
27388 throw new ParseException();
27389 }
27390 switch (jj_nt.kind) {
27391 case 6:
27392 ;
27393 break;
27394 default:
27395 jj_la1[404] = jj_gen;
27396 break label_94;
27397 }
27398 }
27399 jj_consume_token(7);
27400 break;
27401 case EXCEPTION_INIT:
27402 jj_consume_token(EXCEPTION_INIT);
27403 jj_consume_token(5);
27404 jj_consume_token(IDENTIFIER);
27405 jj_consume_token(6);
27406 switch (jj_nt.kind) {
27407 case 16:
27408 case 17:
27409 switch (jj_nt.kind) {
27410 case 16:
27411 jj_consume_token(16);
27412 break;
27413 case 17:
27414 jj_consume_token(17);
27415 break;
27416 default:
27417 jj_la1[405] = jj_gen;
27418 jj_consume_token(-1);
27419 throw new ParseException();
27420 }
27421 break;
27422 default:
27423 jj_la1[406] = jj_gen;
27424 ;
27425 }
27426 NumericLiteral();
27427 jj_consume_token(7);
27428 break;
27429 case INTERFACE:
27430 jj_consume_token(INTERFACE);
27431 jj_consume_token(5);
27432 jj_consume_token(IDENTIFIER);
27433 jj_consume_token(6);
27434 jj_consume_token(IDENTIFIER);
27435 jj_consume_token(6);
27436 NumericLiteral();
27437 jj_consume_token(7);
27438 break;
27439 default:
27440 jj_la1[407] = jj_gen;
27441 jj_consume_token(-1);
27442 throw new ParseException();
27443 }
27444 jjtree.closeNodeScope(jjtn000, true);
27445 jjtc000 = false;
27446 {if (true) return jjtn000 ;}
27447 } catch (Throwable jjte000) {
27448 if (jjtc000) {
27449 jjtree.clearNodeScope(jjtn000);
27450 jjtc000 = false;
27451 } else {
27452 jjtree.popNode();
27453 }
27454 if (jjte000 instanceof RuntimeException) {
27455 {if (true) throw (RuntimeException)jjte000;}
27456 }
27457 if (jjte000 instanceof ParseException) {
27458 {if (true) throw (ParseException)jjte000;}
27459 }
27460 {if (true) throw (Error)jjte000;}
27461 } finally {
27462 if (jjtc000) {
27463 jjtree.closeNodeScope(jjtn000, true);
27464 }
27465 }
27466 throw new Error("Missing return statement in function");
27467 }
27468
27469
27470
27471
27472
27473
27474
27475
27476
27477
27478
27479
27480
27481
27482
27483
27484
27485
27486
27487
27488
27489
27490
27491
27492
27493
27494
27495
27496
27497
27498
27499
27500
27501
27502
27503
27504
27505
27506
27507
27508
27509
27510
27511
27512
27513
27514
27515
27516
27517
27518
27519
27520
27521
27522
27523
27524
27525
27526
27527
27528
27529
27530
27531
27532
27533
27534
27535
27536
27537
27538
27539
27540
27541
27542
27543 final public ASTTriggerUnit TriggerUnit() throws ParseException {
27544
27545 ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
27546 boolean jjtc000 = true;
27547 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
27548 try {
27549 switch (jj_nt.kind) {
27550 case CREATE:
27551 jj_consume_token(CREATE);
27552 switch (jj_nt.kind) {
27553 case OR:
27554 jj_consume_token(OR);
27555 jj_consume_token(REPLACE);
27556 break;
27557 default:
27558 jj_la1[408] = jj_gen;
27559 ;
27560 }
27561 switch (jj_nt.kind) {
27562 case EDITIONABLE:
27563 case NONEDITIONABLE:
27564 switch (jj_nt.kind) {
27565 case EDITIONABLE:
27566 jj_consume_token(EDITIONABLE);
27567 break;
27568 case NONEDITIONABLE:
27569 jj_consume_token(NONEDITIONABLE);
27570 break;
27571 default:
27572 jj_la1[409] = jj_gen;
27573 jj_consume_token(-1);
27574 throw new ParseException();
27575 }
27576 break;
27577 default:
27578 jj_la1[410] = jj_gen;
27579 ;
27580 }
27581 break;
27582 default:
27583 jj_la1[411] = jj_gen;
27584 ;
27585 }
27586 jj_consume_token(TRIGGER);
27587 simpleNode = ObjectNameDeclaration();
27588 switch (jj_nt.kind) {
27589 case BEFORE:
27590 jj_consume_token(BEFORE);
27591 break;
27592 case AFTER:
27593 jj_consume_token(AFTER);
27594 break;
27595 case INSTEADOF:
27596 jj_consume_token(INSTEADOF);
27597 break;
27598 case FOR:
27599 jj_consume_token(FOR);
27600 break;
27601 default:
27602 jj_la1[412] = jj_gen;
27603 jj_consume_token(-1);
27604 throw new ParseException();
27605 }
27606 switch (jj_nt.kind) {
27607 case DELETE:
27608 case INSERT:
27609 case UPDATE:
27610 switch (jj_nt.kind) {
27611 case DELETE:
27612 jj_consume_token(DELETE);
27613 break;
27614 case INSERT:
27615 jj_consume_token(INSERT);
27616 break;
27617 case UPDATE:
27618 jj_consume_token(UPDATE);
27619 break;
27620 default:
27621 jj_la1[413] = jj_gen;
27622 jj_consume_token(-1);
27623 throw new ParseException();
27624 }
27625 if (jj_2_74(6)) {
27626 jj_consume_token(OF);
27627 ID();
27628 label_95:
27629 while (true) {
27630 switch (jj_nt.kind) {
27631 case 6:
27632 ;
27633 break;
27634 default:
27635 jj_la1[414] = jj_gen;
27636 break label_95;
27637 }
27638 jj_consume_token(6);
27639 ID();
27640 }
27641 } else {
27642 ;
27643 }
27644 break;
27645 case ALTER:
27646 case COMMENT:
27647 case CREATE:
27648 case DROP:
27649 case GRANT:
27650 case RENAME:
27651 case REVOKE:
27652 case ANALYZE:
27653 case ASSOCIATE:
27654 case AUDIT:
27655 case DDL:
27656 case DISASSOCIATE:
27657 case LOGOFF:
27658 case LOGON:
27659 case NOAUDIT:
27660 case SERVERERROR:
27661 case SHUTDOWN:
27662 case STARTUP:
27663 case SUSPEND:
27664 case TRUNCATE:
27665 NonDMLEvent();
27666 break;
27667 default:
27668 jj_la1[415] = jj_gen;
27669 jj_consume_token(-1);
27670 throw new ParseException();
27671 }
27672 label_96:
27673 while (true) {
27674 switch (jj_nt.kind) {
27675 case OR:
27676 ;
27677 break;
27678 default:
27679 jj_la1[416] = jj_gen;
27680 break label_96;
27681 }
27682 jj_consume_token(OR);
27683 switch (jj_nt.kind) {
27684 case DELETE:
27685 case INSERT:
27686 case UPDATE:
27687 switch (jj_nt.kind) {
27688 case DELETE:
27689 jj_consume_token(DELETE);
27690 break;
27691 case INSERT:
27692 jj_consume_token(INSERT);
27693 break;
27694 case UPDATE:
27695 jj_consume_token(UPDATE);
27696 break;
27697 default:
27698 jj_la1[417] = jj_gen;
27699 jj_consume_token(-1);
27700 throw new ParseException();
27701 }
27702 if (jj_2_75(6)) {
27703 jj_consume_token(OF);
27704 ID();
27705 label_97:
27706 while (true) {
27707 switch (jj_nt.kind) {
27708 case 6:
27709 ;
27710 break;
27711 default:
27712 jj_la1[418] = jj_gen;
27713 break label_97;
27714 }
27715 jj_consume_token(6);
27716 ID();
27717 }
27718 } else {
27719 ;
27720 }
27721 break;
27722 case ALTER:
27723 case COMMENT:
27724 case CREATE:
27725 case DROP:
27726 case GRANT:
27727 case RENAME:
27728 case REVOKE:
27729 case ANALYZE:
27730 case ASSOCIATE:
27731 case AUDIT:
27732 case DDL:
27733 case DISASSOCIATE:
27734 case LOGOFF:
27735 case LOGON:
27736 case NOAUDIT:
27737 case SERVERERROR:
27738 case SHUTDOWN:
27739 case STARTUP:
27740 case SUSPEND:
27741 case TRUNCATE:
27742 NonDMLEvent();
27743 break;
27744 default:
27745 jj_la1[419] = jj_gen;
27746 jj_consume_token(-1);
27747 throw new ParseException();
27748 }
27749 }
27750 jj_consume_token(ON);
27751 switch (jj_nt.kind) {
27752 case DATABASE:
27753 jj_consume_token(DATABASE);
27754 break;
27755 default:
27756 jj_la1[420] = jj_gen;
27757 if (jj_2_78(2)) {
27758 jj_consume_token(NESTED);
27759 jj_consume_token(TABLE);
27760 ID();
27761 jj_consume_token(OF);
27762 if (jj_2_76(2)) {
27763 ID();
27764 jj_consume_token(3);
27765 } else {
27766 ;
27767 }
27768 ID();
27769 } else {
27770 switch (jj_nt.kind) {
27771 case REPLACE:
27772 case DEFINER:
27773 case CURRENT_USER:
27774 case SERIALLY_REUSABLE:
27775 case RESTRICT_REFERENCES:
27776 case EXCEPTION_INIT:
27777 case AUTONOMOUS_TRANSACTION:
27778 case LANGUAGE:
27779 case INLINE:
27780 case ADD:
27781 case AGGREGATE:
27782 case ALL:
27783 case ALTER:
27784 case AND:
27785 case ANY:
27786 case ARRAY:
27787 case AS:
27788 case ASC:
27789 case AT:
27790 case ATTRIBUTE:
27791 case AUTHID:
27792 case AVG:
27793 case BETWEEN:
27794 case BINARY_INTEGER:
27795 case BODY:
27796 case BOOLEAN:
27797 case BULK:
27798 case BY:
27799 case BYTE:
27800 case CASCADE:
27801 case CASE:
27802 case CHAR:
27803 case CHAR_BASE:
27804 case CHECK:
27805 case CLOSE:
27806 case CLUSTER:
27807 case COALESCE:
27808 case COLLECT:
27809 case COLUMN:
27810 case COMMENT:
27811 case COMMIT:
27812 case COMPRESS:
27813 case CONNECT:
27814 case CONSTANT:
27815 case CONSTRUCTOR:
27816 case CONTINUE:
27817 case CONVERT:
27818 case CREATE:
27819 case CURRENT:
27820 case CURRVAL:
27821 case CURSOR:
27822 case DATA:
27823 case DATE:
27824 case DAY:
27825 case DECLARE:
27826 case DECIMAL:
27827 case _DEFAULT:
27828 case DELETE:
27829 case DESC:
27830 case DISABLE:
27831 case DISTINCT:
27832 case DO:
27833 case DROP:
27834 case EDITIONABLE:
27835 case ELEMENT:
27836 case ELSE:
27837 case ELSIF:
27838 case ENABLE:
27839 case ESCAPE:
27840 case EXCEPT:
27841 case EXCEPTION:
27842 case EXCEPTIONS:
27843 case EXCLUSIVE:
27844 case EXECUTE:
27845 case EXISTS:
27846 case EXIT:
27847 case EXTERNAL:
27848 case EXTENDS:
27849 case EXTRACT:
27850 case FALSE:
27851 case FETCH:
27852 case FINAL:
27853 case FLOAT:
27854 case FOR:
27855 case FORALL:
27856 case FORCE:
27857 case FROM:
27858 case FUNCTION:
27859 case GLOBAL:
27860 case GOTO:
27861 case GROUP:
27862 case HASH:
27863 case HAVING:
27864 case HEAP:
27865 case HOUR:
27866 case IF:
27867 case IMMEDIATE:
27868 case IN:
27869 case INDEX:
27870 case INDICES:
27871 case INDEXTYPE:
27872 case INDICATOR:
27873 case INSERT:
27874 case INSTANTIABLE:
27875 case INTEGER:
27876 case INTERFACE:
27877 case INTERSECT:
27878 case INTERVAL:
27879 case INTO:
27880 case INVALIDATE:
27881 case IS:
27882 case ISOLATION:
27883 case JAVA:
27884 case LEVEL:
27885 case LIKE:
27886 case LIMIT:
27887 case LIMITED:
27888 case LOCK:
27889 case LONG:
27890 case LOOP:
27891 case MAP:
27892 case MAX:
27893 case MEMBER:
27894 case MERGE:
27895 case MIN:
27896 case MINUS:
27897 case MINUTE:
27898 case MLSLABEL:
27899 case MODIFY:
27900 case MOD:
27901 case MODE:
27902 case MONTH:
27903 case NATURAL:
27904 case NATURALN:
27905 case NEW:
27906 case NEXTVAL:
27907 case NO:
27908 case NOCOPY:
27909 case NONEDITIONABLE:
27910 case NOT:
27911 case NOWAIT:
27912 case NULL:
27913 case NULLIF:
27914 case NUMBER:
27915 case BFILE_BASE:
27916 case BLOB_BASE:
27917 case CLOB_BASE:
27918 case DATE_BASE:
27919 case NUMBER_BASE:
27920 case OBJECT:
27921 case OCIROWID:
27922 case OF:
27923 case OID:
27924 case ON:
27925 case OPAQUE:
27926 case OPEN:
27927 case OPERATOR:
27928 case OPTION:
27929 case OR:
27930 case ORDER:
27931 case ORGANIZATION:
27932 case OTHERS:
27933 case OUT:
27934 case OVERRIDING:
27935 case PACKAGE:
27936 case PARTITION:
27937 case PCTFREE:
27938 case PLS_INTEGER:
27939 case POSITIVE:
27940 case POSITIVEN:
27941 case PRESERVE:
27942 case PRIOR:
27943 case PROMPT:
27944 case PRIVATE:
27945 case PROCEDURE:
27946 case PUBLIC:
27947 case RAISE:
27948 case RANGE:
27949 case RAW:
27950 case REAL:
27951 case RECORD:
27952 case REF:
27953 case RELEASE:
27954 case RELIES_ON:
27955 case RENAME:
27956 case RESULT:
27957 case RETURN:
27958 case RETURNING:
27959 case REVERSE:
27960 case ROLLBACK:
27961 case ROW:
27962 case ROWS:
27963 case ROWID:
27964 case ROWNUM:
27965 case ROWTYPE:
27966 case SAVE:
27967 case SAVEPOINT:
27968 case SECOND:
27969 case SELECT:
27970 case SELF:
27971 case SEPARATE:
27972 case SET:
27973 case SHARE:
27974 case SMALLINT:
27975 case SPACE:
27976 case SQL:
27977 case SQLCODE:
27978 case SQLERRM:
27979 case START:
27980 case STATIC:
27981 case STDDEV:
27982 case SUBTYPE:
27983 case SUBSTITUTABLE:
27984 case SUCCESSFUL:
27985 case SUM:
27986 case SYNONYM:
27987 case SYSDATE:
27988 case SYS_REFCURSOR:
27989 case TABLE:
27990 case TEMPORARY:
27991 case THEN:
27992 case TIME:
27993 case TIMESTAMP:
27994 case TIMEZONE_REGION:
27995 case TIMEZONE_ABBR:
27996 case TIMEZONE_MINUTE:
27997 case TIMEZONE_HOUR:
27998 case TO:
27999 case TRANSACTION:
28000 case TRIGGER:
28001 case TRUE:
28002 case TYPE:
28003 case UI:
28004 case UNDER:
28005 case USING:
28006 case WHILE:
28007 case YES:
28008 case SHOW:
28009 case A:
28010 case UPDATE:
28011 case VARCHAR:
28012 case VARCHAR2:
28013 case DOUBLE:
28014 case DEC:
28015 case PRECISION:
28016 case INT:
28017 case NUMERIC:
28018 case SIGNTYPE:
28019 case NCHAR:
28020 case NVARCHAR2:
28021 case STRING:
28022 case UROWID:
28023 case VARRAY:
28024 case VARYING:
28025 case BFILE:
28026 case BLOB:
28027 case CLOB:
28028 case NCLOB:
28029 case YEAR:
28030 case LOCAL:
28031 case WITH:
28032 case ZONE:
28033 case CHARACTER:
28034 case AFTER:
28035 case BEFORE:
28036 case OLD:
28037 case PARENT:
28038 case ANALYZE:
28039 case ASSOCIATE:
28040 case AUDIT:
28041 case COMPOUND:
28042 case DATABASE:
28043 case CALL:
28044 case DDL:
28045 case DISASSOCIATE:
28046 case EACH:
28047 case FOLLOWS:
28048 case LOGOFF:
28049 case LOGON:
28050 case NESTED:
28051 case NOAUDIT:
28052 case SCHEMA:
28053 case SERVERERROR:
28054 case SHUTDOWN:
28055 case STARTUP:
28056 case STATEMENT:
28057 case STATISTICS:
28058 case SUSPEND:
28059 case TRUNCATE:
28060 case WRAPPED:
28061 case LIBRARY:
28062 case NAME:
28063 case STRUCT:
28064 case CONTEXT:
28065 case PARAMETERS:
28066 case LENGTH:
28067 case TDO:
28068 case MAXLEN:
28069 case CHARSETID:
28070 case CHARSETFORM:
28071 case ACCEPT:
28072 case ACCESSIBLE:
28073 case COPY:
28074 case DEFINE:
28075 case DISCONNECT:
28076 case HOST:
28077 case PRINT:
28078 case QUIT:
28079 case REMARK:
28080 case UNDEFINE:
28081 case VARIABLE:
28082 case WHENEVER:
28083 case ATTACH:
28084 case CAST:
28085 case TREAT:
28086 case TRIM:
28087 case LEFT:
28088 case RIGHT:
28089 case BOTH:
28090 case EMPTY:
28091 case MULTISET:
28092 case SUBMULTISET:
28093 case LEADING:
28094 case TRAILING:
28095 case CHAR_CS:
28096 case NCHAR_CS:
28097 case DBTIMEZONE:
28098 case SESSIONTIMEZONE:
28099 case AUTHENTICATED:
28100 case LINK:
28101 case SHARED:
28102 case DIRECTORY:
28103 case USER:
28104 case IDENTIFIER:
28105 case QUOTED_LITERAL:
28106 case SQLDATA_CLASS:
28107 case CUSTOMDATUM_CLASS:
28108 case ORADATA_CLASS:
28109 case JAVA_INTERFACE_CLASS:
28110 if (jj_2_77(2)) {
28111 ID();
28112 jj_consume_token(3);
28113 } else {
28114 ;
28115 }
28116 ID();
28117 break;
28118 default:
28119 jj_la1[421] = jj_gen;
28120 jj_consume_token(-1);
28121 throw new ParseException();
28122 }
28123 }
28124 }
28125 switch (jj_nt.kind) {
28126 case REFERENCING:
28127 jj_consume_token(REFERENCING);
28128 label_98:
28129 while (true) {
28130 switch (jj_nt.kind) {
28131 case NEW:
28132 case OLD:
28133 case PARENT:
28134 ;
28135 break;
28136 default:
28137 jj_la1[422] = jj_gen;
28138 break label_98;
28139 }
28140 switch (jj_nt.kind) {
28141 case OLD:
28142 jj_consume_token(OLD);
28143 break;
28144 case NEW:
28145 jj_consume_token(NEW);
28146 break;
28147 case PARENT:
28148 jj_consume_token(PARENT);
28149 break;
28150 default:
28151 jj_la1[423] = jj_gen;
28152 jj_consume_token(-1);
28153 throw new ParseException();
28154 }
28155 jj_consume_token(AS);
28156 ID();
28157 }
28158 break;
28159 default:
28160 jj_la1[424] = jj_gen;
28161 ;
28162 }
28163 switch (jj_nt.kind) {
28164 case FOREACHROW:
28165 jj_consume_token(FOREACHROW);
28166 break;
28167 default:
28168 jj_la1[425] = jj_gen;
28169 ;
28170 }
28171 switch (jj_nt.kind) {
28172 case REVERSE:
28173 case FORWARD:
28174 case CROSSEDITION:
28175 switch (jj_nt.kind) {
28176 case REVERSE:
28177 case FORWARD:
28178 switch (jj_nt.kind) {
28179 case FORWARD:
28180 jj_consume_token(FORWARD);
28181 break;
28182 case REVERSE:
28183 jj_consume_token(REVERSE);
28184 break;
28185 default:
28186 jj_la1[426] = jj_gen;
28187 jj_consume_token(-1);
28188 throw new ParseException();
28189 }
28190 break;
28191 default:
28192 jj_la1[427] = jj_gen;
28193 ;
28194 }
28195 jj_consume_token(CROSSEDITION);
28196 break;
28197 default:
28198 jj_la1[428] = jj_gen;
28199 ;
28200 }
28201 switch (jj_nt.kind) {
28202 case FOLLOWS:
28203 case PRECEDES:
28204 switch (jj_nt.kind) {
28205 case FOLLOWS:
28206 jj_consume_token(FOLLOWS);
28207 break;
28208 case PRECEDES:
28209 jj_consume_token(PRECEDES);
28210 break;
28211 default:
28212 jj_la1[429] = jj_gen;
28213 jj_consume_token(-1);
28214 throw new ParseException();
28215 }
28216 if (jj_2_79(2)) {
28217 ID();
28218 jj_consume_token(3);
28219 } else {
28220 ;
28221 }
28222 ID();
28223 label_99:
28224 while (true) {
28225 switch (jj_nt.kind) {
28226 case 6:
28227 ;
28228 break;
28229 default:
28230 jj_la1[430] = jj_gen;
28231 break label_99;
28232 }
28233 jj_consume_token(6);
28234 if (jj_2_80(2)) {
28235 ID();
28236 jj_consume_token(3);
28237 } else {
28238 ;
28239 }
28240 ID();
28241 }
28242 break;
28243 default:
28244 jj_la1[431] = jj_gen;
28245 ;
28246 }
28247 switch (jj_nt.kind) {
28248 case DISABLE:
28249 case ENABLE:
28250 switch (jj_nt.kind) {
28251 case ENABLE:
28252 jj_consume_token(ENABLE);
28253 break;
28254 case DISABLE:
28255 jj_consume_token(DISABLE);
28256 break;
28257 default:
28258 jj_la1[432] = jj_gen;
28259 jj_consume_token(-1);
28260 throw new ParseException();
28261 }
28262 break;
28263 default:
28264 jj_la1[433] = jj_gen;
28265 ;
28266 }
28267 switch (jj_nt.kind) {
28268 case WHEN:
28269 jj_consume_token(WHEN);
28270 jj_consume_token(5);
28271 ConditionalOrExpression();
28272 jj_consume_token(7);
28273 break;
28274 default:
28275 jj_la1[434] = jj_gen;
28276 ;
28277 }
28278 switch (jj_nt.kind) {
28279 case CALL:
28280 jj_consume_token(CALL);
28281 PrimaryExpression();
28282 jj_consume_token(4);
28283 break;
28284 case COMPOUND:
28285 CompoundTriggerBlock();
28286 break;
28287 case BEGIN:
28288 case DECLARE:
28289 Block();
28290 jj_consume_token(4);
28291 break;
28292 default:
28293 jj_la1[435] = jj_gen;
28294 jj_consume_token(-1);
28295 throw new ParseException();
28296 }
28297 jjtree.closeNodeScope(jjtn000, true);
28298 jjtc000 = false;
28299 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
28300 } catch (Throwable jjte000) {
28301 if (jjtc000) {
28302 jjtree.clearNodeScope(jjtn000);
28303 jjtc000 = false;
28304 } else {
28305 jjtree.popNode();
28306 }
28307 if (jjte000 instanceof RuntimeException) {
28308 {if (true) throw (RuntimeException)jjte000;}
28309 }
28310 if (jjte000 instanceof ParseException) {
28311 {if (true) throw (ParseException)jjte000;}
28312 }
28313 {if (true) throw (Error)jjte000;}
28314 } finally {
28315 if (jjtc000) {
28316 jjtree.closeNodeScope(jjtn000, true);
28317 }
28318 }
28319 throw new Error("Missing return statement in function");
28320 }
28321
28322 final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
28323
28324 ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
28325 boolean jjtc000 = true;
28326 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
28327 try {
28328 switch (jj_nt.kind) {
28329 case BEFORE:
28330 jj_consume_token(BEFORE);
28331 break;
28332 case AFTER:
28333 jj_consume_token(AFTER);
28334 break;
28335 case INSTEADOF:
28336 jj_consume_token(INSTEADOF);
28337 break;
28338 default:
28339 jj_la1[436] = jj_gen;
28340 jj_consume_token(-1);
28341 throw new ParseException();
28342 }
28343 sb.append(token.image) ;
28344 switch (jj_nt.kind) {
28345 case STATEMENT:
28346 jj_consume_token(STATEMENT);
28347 break;
28348 case EACH:
28349 jj_consume_token(EACH);
28350 jj_consume_token(ROW);
28351 break;
28352 default:
28353 jj_la1[437] = jj_gen;
28354 jj_consume_token(-1);
28355 throw new ParseException();
28356 }
28357 sb.append(" "); sb.append(token.image) ;
28358 jj_consume_token(IS);
28359 jj_consume_token(BEGIN);
28360 label_100:
28361 while (true) {
28362 Statement();
28363 switch (jj_nt.kind) {
28364 case 5:
28365 case 16:
28366 case 17:
28367 case 21:
28368 case REPLACE:
28369 case DEFINER:
28370 case CURRENT_USER:
28371 case LANGUAGE:
28372 case INLINE:
28373 case ADD:
28374 case AGGREGATE:
28375 case ARRAY:
28376 case AT:
28377 case ATTRIBUTE:
28378 case AUTHID:
28379 case BEGIN:
28380 case BODY:
28381 case BULK:
28382 case BYTE:
28383 case CASCADE:
28384 case CASE:
28385 case CLOSE:
28386 case COALESCE:
28387 case COLLECT:
28388 case COLUMN:
28389 case COMMENT:
28390 case COMMIT:
28391 case CONSTRUCTOR:
28392 case CONTINUE:
28393 case CONVERT:
28394 case CURRENT:
28395 case CURSOR:
28396 case DATA:
28397 case DATE:
28398 case DAY:
28399 case DECLARE:
28400 case DELETE:
28401 case DISABLE:
28402 case EDITIONABLE:
28403 case ELEMENT:
28404 case ENABLE:
28405 case ESCAPE:
28406 case EXCEPT:
28407 case EXCEPTIONS:
28408 case EXECUTE:
28409 case EXIT:
28410 case EXTERNAL:
28411 case EXTENDS:
28412 case EXTRACT:
28413 case FALSE:
28414 case FETCH:
28415 case FINAL:
28416 case FOR:
28417 case FORALL:
28418 case FORCE:
28419 case FUNCTION:
28420 case GLOBAL:
28421 case GOTO:
28422 case HASH:
28423 case HEAP:
28424 case HOUR:
28425 case IF:
28426 case IMMEDIATE:
28427 case INDICES:
28428 case INDEXTYPE:
28429 case INDICATOR:
28430 case INSERT:
28431 case INSTANTIABLE:
28432 case INTERVAL:
28433 case INVALIDATE:
28434 case ISOLATION:
28435 case JAVA:
28436 case LEVEL:
28437 case LIMIT:
28438 case LOCK:
28439 case LOOP:
28440 case MAP:
28441 case MAX:
28442 case MEMBER:
28443 case MERGE:
28444 case MIN:
28445 case MINUTE:
28446 case MLSLABEL:
28447 case MODIFY:
28448 case MOD:
28449 case MONTH:
28450 case NATURAL:
28451 case NEW:
28452 case NEW_DOT:
28453 case NO:
28454 case NONEDITIONABLE:
28455 case NOT:
28456 case NULL:
28457 case NULLIF:
28458 case OBJECT:
28459 case OID:
28460 case OPAQUE:
28461 case OPEN:
28462 case OPERATOR:
28463 case ORGANIZATION:
28464 case OTHERS:
28465 case OVERRIDING:
28466 case PACKAGE:
28467 case PARTITION:
28468 case PIPE:
28469 case PRAGMA:
28470 case PRESERVE:
28471 case PRIVATE:
28472 case PROCEDURE:
28473 case RAISE:
28474 case RANGE:
28475 case RAW:
28476 case REAL:
28477 case RECORD:
28478 case REF:
28479 case RELEASE:
28480 case RELIES_ON:
28481 case RENAME:
28482 case RESULT:
28483 case RETURN:
28484 case RETURNING:
28485 case REVERSE:
28486 case ROLLBACK:
28487 case ROW:
28488 case ROWS:
28489 case ROWID:
28490 case ROWNUM:
28491 case SAVE:
28492 case SAVEPOINT:
28493 case SECOND:
28494 case SELECT:
28495 case SELF:
28496 case SET:
28497 case SPACE:
28498 case SQL:
28499 case SQLCODE:
28500 case SQLERRM:
28501 case STATIC:
28502 case SUBTYPE:
28503 case SUBSTITUTABLE:
28504 case SUCCESSFUL:
28505 case SYSDATE:
28506 case SYS_REFCURSOR:
28507 case TEMPORARY:
28508 case TIME:
28509 case TIMESTAMP:
28510 case TIMEZONE_REGION:
28511 case TIMEZONE_ABBR:
28512 case TIMEZONE_MINUTE:
28513 case TIMEZONE_HOUR:
28514 case TRANSACTION:
28515 case TRUE:
28516 case TYPE:
28517 case UNDER:
28518 case USING:
28519 case WHILE:
28520 case YES:
28521 case SHOW:
28522 case A:
28523 case UPDATE:
28524 case DOUBLE:
28525 case DEC:
28526 case PRECISION:
28527 case INT:
28528 case NUMERIC:
28529 case NCHAR:
28530 case NVARCHAR2:
28531 case STRING:
28532 case UROWID:
28533 case VARRAY:
28534 case VARYING:
28535 case BFILE:
28536 case BLOB:
28537 case CLOB:
28538 case NCLOB:
28539 case YEAR:
28540 case LOCAL:
28541 case WITH:
28542 case ZONE:
28543 case CHARACTER:
28544 case AFTER:
28545 case BEFORE:
28546 case OLD:
28547 case PARENT:
28548 case CC_IF:
28549 case CC_ERROR:
28550 case ANALYZE:
28551 case ASSOCIATE:
28552 case AUDIT:
28553 case COMPOUND:
28554 case DATABASE:
28555 case CALL:
28556 case DDL:
28557 case DISASSOCIATE:
28558 case EACH:
28559 case FOLLOWS:
28560 case LOGOFF:
28561 case LOGON:
28562 case NESTED:
28563 case NOAUDIT:
28564 case SCHEMA:
28565 case SERVERERROR:
28566 case SHUTDOWN:
28567 case STARTUP:
28568 case STATEMENT:
28569 case STATISTICS:
28570 case SUSPEND:
28571 case TRUNCATE:
28572 case WRAPPED:
28573 case LIBRARY:
28574 case NAME:
28575 case STRUCT:
28576 case CONTEXT:
28577 case PARAMETERS:
28578 case LENGTH:
28579 case TDO:
28580 case MAXLEN:
28581 case CHARSETID:
28582 case CHARSETFORM:
28583 case ACCEPT:
28584 case ACCESSIBLE:
28585 case COPY:
28586 case DEFINE:
28587 case DISCONNECT:
28588 case HOST:
28589 case PRINT:
28590 case QUIT:
28591 case REMARK:
28592 case UNDEFINE:
28593 case VARIABLE:
28594 case WHENEVER:
28595 case ATTACH:
28596 case CAST:
28597 case TREAT:
28598 case TRIM:
28599 case LEFT:
28600 case RIGHT:
28601 case BOTH:
28602 case EMPTY:
28603 case MULTISET:
28604 case SUBMULTISET:
28605 case LEADING:
28606 case TRAILING:
28607 case CHAR_CS:
28608 case NCHAR_CS:
28609 case DBTIMEZONE:
28610 case SESSIONTIMEZONE:
28611 case AUTHENTICATED:
28612 case LINK:
28613 case SHARED:
28614 case DIRECTORY:
28615 case USER:
28616 case IDENTIFIER:
28617 case UNSIGNED_NUMERIC_LITERAL:
28618 case CHARACTER_LITERAL:
28619 case STRING_LITERAL:
28620 case QUOTED_LITERAL:
28621 ;
28622 break;
28623 default:
28624 jj_la1[438] = jj_gen;
28625 break label_100;
28626 }
28627 }
28628 jj_consume_token(END);
28629 switch (jj_nt.kind) {
28630 case BEFORE:
28631 jj_consume_token(BEFORE);
28632 break;
28633 case AFTER:
28634 jj_consume_token(AFTER);
28635 break;
28636 case INSTEADOF:
28637 jj_consume_token(INSTEADOF);
28638 break;
28639 default:
28640 jj_la1[439] = jj_gen;
28641 jj_consume_token(-1);
28642 throw new ParseException();
28643 }
28644 switch (jj_nt.kind) {
28645 case STATEMENT:
28646 jj_consume_token(STATEMENT);
28647 break;
28648 case EACH:
28649 jj_consume_token(EACH);
28650 jj_consume_token(ROW);
28651 break;
28652 default:
28653 jj_la1[440] = jj_gen;
28654 jj_consume_token(-1);
28655 throw new ParseException();
28656 }
28657 jj_consume_token(4);
28658
28659 jjtree.closeNodeScope(jjtn000, true);
28660 jjtc000 = false;
28661 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
28662 } catch (Throwable jjte000) {
28663 if (jjtc000) {
28664 jjtree.clearNodeScope(jjtn000);
28665 jjtc000 = false;
28666 } else {
28667 jjtree.popNode();
28668 }
28669 if (jjte000 instanceof RuntimeException) {
28670 {if (true) throw (RuntimeException)jjte000;}
28671 }
28672 if (jjte000 instanceof ParseException) {
28673 {if (true) throw (ParseException)jjte000;}
28674 }
28675 {if (true) throw (Error)jjte000;}
28676 } finally {
28677 if (jjtc000) {
28678 jjtree.closeNodeScope(jjtn000, true);
28679 }
28680 }
28681 throw new Error("Missing return statement in function");
28682 }
28683
28684 final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
28685
28686 ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
28687 boolean jjtc000 = true;
28688 jjtree.openNodeScope(jjtn000);
28689 try {
28690 jj_consume_token(COMPOUND);
28691 jj_consume_token(TRIGGER);
28692 label_101:
28693 while (true) {
28694 switch (jj_nt.kind) {
28695 case REPLACE:
28696 case DEFINER:
28697 case CURRENT_USER:
28698 case SERIALLY_REUSABLE:
28699 case RESTRICT_REFERENCES:
28700 case EXCEPTION_INIT:
28701 case AUTONOMOUS_TRANSACTION:
28702 case LANGUAGE:
28703 case INLINE:
28704 case ADD:
28705 case AGGREGATE:
28706 case ALL:
28707 case ALTER:
28708 case AND:
28709 case ANY:
28710 case ARRAY:
28711 case AS:
28712 case ASC:
28713 case AT:
28714 case ATTRIBUTE:
28715 case AUTHID:
28716 case AVG:
28717 case BETWEEN:
28718 case BINARY_INTEGER:
28719 case BODY:
28720 case BOOLEAN:
28721 case BULK:
28722 case BY:
28723 case BYTE:
28724 case CASCADE:
28725 case CASE:
28726 case CHAR:
28727 case CHAR_BASE:
28728 case CHECK:
28729 case CLOSE:
28730 case CLUSTER:
28731 case COALESCE:
28732 case COLLECT:
28733 case COLUMN:
28734 case COMMENT:
28735 case COMMIT:
28736 case COMPRESS:
28737 case CONNECT:
28738 case CONSTANT:
28739 case CONSTRUCTOR:
28740 case CONTINUE:
28741 case CONVERT:
28742 case CREATE:
28743 case CURRENT:
28744 case CURRVAL:
28745 case CURSOR:
28746 case DATA:
28747 case DATE:
28748 case DAY:
28749 case DECLARE:
28750 case DECIMAL:
28751 case _DEFAULT:
28752 case DELETE:
28753 case DESC:
28754 case DISABLE:
28755 case DISTINCT:
28756 case DO:
28757 case DROP:
28758 case EDITIONABLE:
28759 case ELEMENT:
28760 case ELSE:
28761 case ELSIF:
28762 case ENABLE:
28763 case ESCAPE:
28764 case EXCEPT:
28765 case EXCEPTION:
28766 case EXCEPTIONS:
28767 case EXCLUSIVE:
28768 case EXECUTE:
28769 case EXISTS:
28770 case EXIT:
28771 case EXTERNAL:
28772 case EXTENDS:
28773 case EXTRACT:
28774 case FALSE:
28775 case FETCH:
28776 case FINAL:
28777 case FLOAT:
28778 case FOR:
28779 case FORALL:
28780 case FORCE:
28781 case FROM:
28782 case FUNCTION:
28783 case GLOBAL:
28784 case GOTO:
28785 case GROUP:
28786 case HASH:
28787 case HAVING:
28788 case HEAP:
28789 case HOUR:
28790 case IF:
28791 case IMMEDIATE:
28792 case IN:
28793 case INDEX:
28794 case INDICES:
28795 case INDEXTYPE:
28796 case INDICATOR:
28797 case INSERT:
28798 case INSTANTIABLE:
28799 case INTEGER:
28800 case INTERFACE:
28801 case INTERSECT:
28802 case INTERVAL:
28803 case INTO:
28804 case INVALIDATE:
28805 case IS:
28806 case ISOLATION:
28807 case JAVA:
28808 case LEVEL:
28809 case LIKE:
28810 case LIMIT:
28811 case LIMITED:
28812 case LOCK:
28813 case LONG:
28814 case LOOP:
28815 case MAP:
28816 case MAX:
28817 case MEMBER:
28818 case MERGE:
28819 case MIN:
28820 case MINUS:
28821 case MINUTE:
28822 case MLSLABEL:
28823 case MODIFY:
28824 case MOD:
28825 case MODE:
28826 case MONTH:
28827 case NATURAL:
28828 case NATURALN:
28829 case NEW:
28830 case NEXTVAL:
28831 case NO:
28832 case NOCOPY:
28833 case NONEDITIONABLE:
28834 case NOT:
28835 case NOWAIT:
28836 case NULL:
28837 case NULLIF:
28838 case NUMBER:
28839 case BFILE_BASE:
28840 case BLOB_BASE:
28841 case CLOB_BASE:
28842 case DATE_BASE:
28843 case NUMBER_BASE:
28844 case OBJECT:
28845 case OCIROWID:
28846 case OF:
28847 case OID:
28848 case ON:
28849 case OPAQUE:
28850 case OPEN:
28851 case OPERATOR:
28852 case OPTION:
28853 case OR:
28854 case ORDER:
28855 case ORGANIZATION:
28856 case OTHERS:
28857 case OUT:
28858 case OVERRIDING:
28859 case PACKAGE:
28860 case PARTITION:
28861 case PCTFREE:
28862 case PLS_INTEGER:
28863 case POSITIVE:
28864 case POSITIVEN:
28865 case PRAGMA:
28866 case PRESERVE:
28867 case PRIOR:
28868 case PROMPT:
28869 case PRIVATE:
28870 case PROCEDURE:
28871 case PUBLIC:
28872 case RAISE:
28873 case RANGE:
28874 case RAW:
28875 case REAL:
28876 case RECORD:
28877 case REF:
28878 case RELEASE:
28879 case RELIES_ON:
28880 case RENAME:
28881 case RESULT:
28882 case RETURN:
28883 case RETURNING:
28884 case REVERSE:
28885 case ROLLBACK:
28886 case ROW:
28887 case ROWS:
28888 case ROWID:
28889 case ROWNUM:
28890 case ROWTYPE:
28891 case SAVE:
28892 case SAVEPOINT:
28893 case SECOND:
28894 case SELECT:
28895 case SELF:
28896 case SEPARATE:
28897 case SET:
28898 case SHARE:
28899 case SMALLINT:
28900 case SPACE:
28901 case SQL:
28902 case SQLCODE:
28903 case SQLERRM:
28904 case START:
28905 case STATIC:
28906 case STDDEV:
28907 case SUBTYPE:
28908 case SUBSTITUTABLE:
28909 case SUCCESSFUL:
28910 case SUM:
28911 case SYNONYM:
28912 case SYSDATE:
28913 case SYS_REFCURSOR:
28914 case TABLE:
28915 case TEMPORARY:
28916 case THEN:
28917 case TIME:
28918 case TIMESTAMP:
28919 case TIMEZONE_REGION:
28920 case TIMEZONE_ABBR:
28921 case TIMEZONE_MINUTE:
28922 case TIMEZONE_HOUR:
28923 case TO:
28924 case TRANSACTION:
28925 case TRIGGER:
28926 case TRUE:
28927 case TYPE:
28928 case UI:
28929 case UNDER:
28930 case USING:
28931 case WHILE:
28932 case YES:
28933 case SHOW:
28934 case A:
28935 case UPDATE:
28936 case VARCHAR:
28937 case VARCHAR2:
28938 case DOUBLE:
28939 case DEC:
28940 case PRECISION:
28941 case INT:
28942 case NUMERIC:
28943 case SIGNTYPE:
28944 case NCHAR:
28945 case NVARCHAR2:
28946 case STRING:
28947 case UROWID:
28948 case VARRAY:
28949 case VARYING:
28950 case BFILE:
28951 case BLOB:
28952 case CLOB:
28953 case NCLOB:
28954 case YEAR:
28955 case LOCAL:
28956 case WITH:
28957 case ZONE:
28958 case CHARACTER:
28959 case AFTER:
28960 case BEFORE:
28961 case INSTEADOF:
28962 case OLD:
28963 case PARENT:
28964 case ANALYZE:
28965 case ASSOCIATE:
28966 case AUDIT:
28967 case COMPOUND:
28968 case DATABASE:
28969 case CALL:
28970 case DDL:
28971 case DISASSOCIATE:
28972 case EACH:
28973 case FOLLOWS:
28974 case LOGOFF:
28975 case LOGON:
28976 case NESTED:
28977 case NOAUDIT:
28978 case SCHEMA:
28979 case SERVERERROR:
28980 case SHUTDOWN:
28981 case STARTUP:
28982 case STATEMENT:
28983 case STATISTICS:
28984 case SUSPEND:
28985 case TRUNCATE:
28986 case WRAPPED:
28987 case LIBRARY:
28988 case NAME:
28989 case STRUCT:
28990 case CONTEXT:
28991 case PARAMETERS:
28992 case LENGTH:
28993 case TDO:
28994 case MAXLEN:
28995 case CHARSETID:
28996 case CHARSETFORM:
28997 case ACCEPT:
28998 case ACCESSIBLE:
28999 case COPY:
29000 case DEFINE:
29001 case DISCONNECT:
29002 case HOST:
29003 case PRINT:
29004 case QUIT:
29005 case REMARK:
29006 case UNDEFINE:
29007 case VARIABLE:
29008 case WHENEVER:
29009 case ATTACH:
29010 case CAST:
29011 case TREAT:
29012 case TRIM:
29013 case LEFT:
29014 case RIGHT:
29015 case BOTH:
29016 case EMPTY:
29017 case MULTISET:
29018 case SUBMULTISET:
29019 case LEADING:
29020 case TRAILING:
29021 case CHAR_CS:
29022 case NCHAR_CS:
29023 case DBTIMEZONE:
29024 case SESSIONTIMEZONE:
29025 case AUTHENTICATED:
29026 case LINK:
29027 case SHARED:
29028 case DIRECTORY:
29029 case USER:
29030 case IDENTIFIER:
29031 case QUOTED_LITERAL:
29032 case SQLDATA_CLASS:
29033 case CUSTOMDATUM_CLASS:
29034 case ORADATA_CLASS:
29035 case JAVA_INTERFACE_CLASS:
29036 ;
29037 break;
29038 default:
29039 jj_la1[441] = jj_gen;
29040 break label_101;
29041 }
29042 switch (jj_nt.kind) {
29043 case AFTER:
29044 case BEFORE:
29045 case INSTEADOF:
29046 TriggerTimingPointSection();
29047 break;
29048 case PRAGMA:
29049 Pragma();
29050 break;
29051 default:
29052 jj_la1[442] = jj_gen;
29053 if (jj_2_81(2)) {
29054 ExceptionDeclaration();
29055 } else if (jj_2_82(2)) {
29056 SubTypeDefinition();
29057 } else if (jj_2_83(4)) {
29058 VariableOrConstantDeclaration();
29059 } else if (jj_2_84(2)) {
29060 CursorSpecification();
29061 } else {
29062 switch (jj_nt.kind) {
29063 case CURSOR:
29064 CursorBody();
29065 break;
29066 case IDENTIFIER:
29067 CollectionDeclaration();
29068 break;
29069 case CREATE:
29070 case FUNCTION:
29071 case PROCEDURE:
29072 ProgramUnit();
29073 break;
29074 default:
29075 jj_la1[443] = jj_gen;
29076 jj_consume_token(-1);
29077 throw new ParseException();
29078 }
29079 }
29080 }
29081 }
29082 jj_consume_token(END);
29083 switch (jj_nt.kind) {
29084 case REPLACE:
29085 case DEFINER:
29086 case CURRENT_USER:
29087 case SERIALLY_REUSABLE:
29088 case RESTRICT_REFERENCES:
29089 case EXCEPTION_INIT:
29090 case AUTONOMOUS_TRANSACTION:
29091 case LANGUAGE:
29092 case INLINE:
29093 case ADD:
29094 case AGGREGATE:
29095 case ALL:
29096 case ALTER:
29097 case AND:
29098 case ANY:
29099 case ARRAY:
29100 case AS:
29101 case ASC:
29102 case AT:
29103 case ATTRIBUTE:
29104 case AUTHID:
29105 case AVG:
29106 case BETWEEN:
29107 case BINARY_INTEGER:
29108 case BODY:
29109 case BOOLEAN:
29110 case BULK:
29111 case BY:
29112 case BYTE:
29113 case CASCADE:
29114 case CASE:
29115 case CHAR:
29116 case CHAR_BASE:
29117 case CHECK:
29118 case CLOSE:
29119 case CLUSTER:
29120 case COALESCE:
29121 case COLLECT:
29122 case COLUMN:
29123 case COMMENT:
29124 case COMMIT:
29125 case COMPRESS:
29126 case CONNECT:
29127 case CONSTANT:
29128 case CONSTRUCTOR:
29129 case CONTINUE:
29130 case CONVERT:
29131 case CREATE:
29132 case CURRENT:
29133 case CURRVAL:
29134 case CURSOR:
29135 case DATA:
29136 case DATE:
29137 case DAY:
29138 case DECLARE:
29139 case DECIMAL:
29140 case _DEFAULT:
29141 case DELETE:
29142 case DESC:
29143 case DISABLE:
29144 case DISTINCT:
29145 case DO:
29146 case DROP:
29147 case EDITIONABLE:
29148 case ELEMENT:
29149 case ELSE:
29150 case ELSIF:
29151 case ENABLE:
29152 case ESCAPE:
29153 case EXCEPT:
29154 case EXCEPTION:
29155 case EXCEPTIONS:
29156 case EXCLUSIVE:
29157 case EXECUTE:
29158 case EXISTS:
29159 case EXIT:
29160 case EXTERNAL:
29161 case EXTENDS:
29162 case EXTRACT:
29163 case FALSE:
29164 case FETCH:
29165 case FINAL:
29166 case FLOAT:
29167 case FOR:
29168 case FORALL:
29169 case FORCE:
29170 case FROM:
29171 case FUNCTION:
29172 case GLOBAL:
29173 case GOTO:
29174 case GROUP:
29175 case HASH:
29176 case HAVING:
29177 case HEAP:
29178 case HOUR:
29179 case IF:
29180 case IMMEDIATE:
29181 case IN:
29182 case INDEX:
29183 case INDICES:
29184 case INDEXTYPE:
29185 case INDICATOR:
29186 case INSERT:
29187 case INSTANTIABLE:
29188 case INTEGER:
29189 case INTERFACE:
29190 case INTERSECT:
29191 case INTERVAL:
29192 case INTO:
29193 case INVALIDATE:
29194 case IS:
29195 case ISOLATION:
29196 case JAVA:
29197 case LEVEL:
29198 case LIKE:
29199 case LIMIT:
29200 case LIMITED:
29201 case LOCK:
29202 case LONG:
29203 case LOOP:
29204 case MAP:
29205 case MAX:
29206 case MEMBER:
29207 case MERGE:
29208 case MIN:
29209 case MINUS:
29210 case MINUTE:
29211 case MLSLABEL:
29212 case MODIFY:
29213 case MOD:
29214 case MODE:
29215 case MONTH:
29216 case NATURAL:
29217 case NATURALN:
29218 case NEW:
29219 case NEXTVAL:
29220 case NO:
29221 case NOCOPY:
29222 case NONEDITIONABLE:
29223 case NOT:
29224 case NOWAIT:
29225 case NULL:
29226 case NULLIF:
29227 case NUMBER:
29228 case BFILE_BASE:
29229 case BLOB_BASE:
29230 case CLOB_BASE:
29231 case DATE_BASE:
29232 case NUMBER_BASE:
29233 case OBJECT:
29234 case OCIROWID:
29235 case OF:
29236 case OID:
29237 case ON:
29238 case OPAQUE:
29239 case OPEN:
29240 case OPERATOR:
29241 case OPTION:
29242 case OR:
29243 case ORDER:
29244 case ORGANIZATION:
29245 case OTHERS:
29246 case OUT:
29247 case OVERRIDING:
29248 case PACKAGE:
29249 case PARTITION:
29250 case PCTFREE:
29251 case PLS_INTEGER:
29252 case POSITIVE:
29253 case POSITIVEN:
29254 case PRESERVE:
29255 case PRIOR:
29256 case PROMPT:
29257 case PRIVATE:
29258 case PROCEDURE:
29259 case PUBLIC:
29260 case RAISE:
29261 case RANGE:
29262 case RAW:
29263 case REAL:
29264 case RECORD:
29265 case REF:
29266 case RELEASE:
29267 case RELIES_ON:
29268 case RENAME:
29269 case RESULT:
29270 case RETURN:
29271 case RETURNING:
29272 case REVERSE:
29273 case ROLLBACK:
29274 case ROW:
29275 case ROWS:
29276 case ROWID:
29277 case ROWNUM:
29278 case ROWTYPE:
29279 case SAVE:
29280 case SAVEPOINT:
29281 case SECOND:
29282 case SELECT:
29283 case SELF:
29284 case SEPARATE:
29285 case SET:
29286 case SHARE:
29287 case SMALLINT:
29288 case SPACE:
29289 case SQL:
29290 case SQLCODE:
29291 case SQLERRM:
29292 case START:
29293 case STATIC:
29294 case STDDEV:
29295 case SUBTYPE:
29296 case SUBSTITUTABLE:
29297 case SUCCESSFUL:
29298 case SUM:
29299 case SYNONYM:
29300 case SYSDATE:
29301 case SYS_REFCURSOR:
29302 case TABLE:
29303 case TEMPORARY:
29304 case THEN:
29305 case TIME:
29306 case TIMESTAMP:
29307 case TIMEZONE_REGION:
29308 case TIMEZONE_ABBR:
29309 case TIMEZONE_MINUTE:
29310 case TIMEZONE_HOUR:
29311 case TO:
29312 case TRANSACTION:
29313 case TRIGGER:
29314 case TRUE:
29315 case TYPE:
29316 case UI:
29317 case UNDER:
29318 case USING:
29319 case WHILE:
29320 case YES:
29321 case SHOW:
29322 case A:
29323 case UPDATE:
29324 case VARCHAR:
29325 case VARCHAR2:
29326 case DOUBLE:
29327 case DEC:
29328 case PRECISION:
29329 case INT:
29330 case NUMERIC:
29331 case SIGNTYPE:
29332 case NCHAR:
29333 case NVARCHAR2:
29334 case STRING:
29335 case UROWID:
29336 case VARRAY:
29337 case VARYING:
29338 case BFILE:
29339 case BLOB:
29340 case CLOB:
29341 case NCLOB:
29342 case YEAR:
29343 case LOCAL:
29344 case WITH:
29345 case ZONE:
29346 case CHARACTER:
29347 case AFTER:
29348 case BEFORE:
29349 case OLD:
29350 case PARENT:
29351 case ANALYZE:
29352 case ASSOCIATE:
29353 case AUDIT:
29354 case COMPOUND:
29355 case DATABASE:
29356 case CALL:
29357 case DDL:
29358 case DISASSOCIATE:
29359 case EACH:
29360 case FOLLOWS:
29361 case LOGOFF:
29362 case LOGON:
29363 case NESTED:
29364 case NOAUDIT:
29365 case SCHEMA:
29366 case SERVERERROR:
29367 case SHUTDOWN:
29368 case STARTUP:
29369 case STATEMENT:
29370 case STATISTICS:
29371 case SUSPEND:
29372 case TRUNCATE:
29373 case WRAPPED:
29374 case LIBRARY:
29375 case NAME:
29376 case STRUCT:
29377 case CONTEXT:
29378 case PARAMETERS:
29379 case LENGTH:
29380 case TDO:
29381 case MAXLEN:
29382 case CHARSETID:
29383 case CHARSETFORM:
29384 case ACCEPT:
29385 case ACCESSIBLE:
29386 case COPY:
29387 case DEFINE:
29388 case DISCONNECT:
29389 case HOST:
29390 case PRINT:
29391 case QUIT:
29392 case REMARK:
29393 case UNDEFINE:
29394 case VARIABLE:
29395 case WHENEVER:
29396 case ATTACH:
29397 case CAST:
29398 case TREAT:
29399 case TRIM:
29400 case LEFT:
29401 case RIGHT:
29402 case BOTH:
29403 case EMPTY:
29404 case MULTISET:
29405 case SUBMULTISET:
29406 case LEADING:
29407 case TRAILING:
29408 case CHAR_CS:
29409 case NCHAR_CS:
29410 case DBTIMEZONE:
29411 case SESSIONTIMEZONE:
29412 case AUTHENTICATED:
29413 case LINK:
29414 case SHARED:
29415 case DIRECTORY:
29416 case USER:
29417 case IDENTIFIER:
29418 case QUOTED_LITERAL:
29419 case SQLDATA_CLASS:
29420 case CUSTOMDATUM_CLASS:
29421 case ORADATA_CLASS:
29422 case JAVA_INTERFACE_CLASS:
29423 ID();
29424 break;
29425 default:
29426 jj_la1[444] = jj_gen;
29427 ;
29428 }
29429 jj_consume_token(4);
29430 jjtree.closeNodeScope(jjtn000, true);
29431 jjtc000 = false;
29432 {if (true) return jjtn000 ;}
29433 } catch (Throwable jjte000) {
29434 if (jjtc000) {
29435 jjtree.clearNodeScope(jjtn000);
29436 jjtc000 = false;
29437 } else {
29438 jjtree.popNode();
29439 }
29440 if (jjte000 instanceof RuntimeException) {
29441 {if (true) throw (RuntimeException)jjte000;}
29442 }
29443 if (jjte000 instanceof ParseException) {
29444 {if (true) throw (ParseException)jjte000;}
29445 }
29446 {if (true) throw (Error)jjte000;}
29447 } finally {
29448 if (jjtc000) {
29449 jjtree.closeNodeScope(jjtn000, true);
29450 }
29451 }
29452 throw new Error("Missing return statement in function");
29453 }
29454
29455
29456
29457
29458
29459
29460
29461
29462 final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
29463
29464 ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
29465 boolean jjtc000 = true;
29466 jjtree.openNodeScope(jjtn000);
29467 try {
29468 switch (jj_nt.kind) {
29469 case BEFORE:
29470 jj_consume_token(BEFORE);
29471 break;
29472 case AFTER:
29473 jj_consume_token(AFTER);
29474 break;
29475 default:
29476 jj_la1[445] = jj_gen;
29477 jj_consume_token(-1);
29478 throw new ParseException();
29479 }
29480 switch (jj_nt.kind) {
29481 case ALTER:
29482 case COMMENT:
29483 case CREATE:
29484 case DROP:
29485 case GRANT:
29486 case RENAME:
29487 case REVOKE:
29488 case ANALYZE:
29489 case ASSOCIATE:
29490 case AUDIT:
29491 case DDL:
29492 case DISASSOCIATE:
29493 case NOAUDIT:
29494 case TRUNCATE:
29495 DDLEvent();
29496 break;
29497 case LOGOFF:
29498 case LOGON:
29499 case SERVERERROR:
29500 case SHUTDOWN:
29501 case STARTUP:
29502 case SUSPEND:
29503 DatabaseEvent();
29504 break;
29505 default:
29506 jj_la1[446] = jj_gen;
29507 jj_consume_token(-1);
29508 throw new ParseException();
29509 }
29510 label_102:
29511 while (true) {
29512 switch (jj_nt.kind) {
29513 case OR:
29514 ;
29515 break;
29516 default:
29517 jj_la1[447] = jj_gen;
29518 break label_102;
29519 }
29520 jj_consume_token(OR);
29521 switch (jj_nt.kind) {
29522 case ALTER:
29523 case COMMENT:
29524 case CREATE:
29525 case DROP:
29526 case GRANT:
29527 case RENAME:
29528 case REVOKE:
29529 case ANALYZE:
29530 case ASSOCIATE:
29531 case AUDIT:
29532 case DDL:
29533 case DISASSOCIATE:
29534 case NOAUDIT:
29535 case TRUNCATE:
29536 DDLEvent();
29537 break;
29538 case LOGOFF:
29539 case LOGON:
29540 case SERVERERROR:
29541 case SHUTDOWN:
29542 case STARTUP:
29543 case SUSPEND:
29544 DatabaseEvent();
29545 break;
29546 default:
29547 jj_la1[448] = jj_gen;
29548 jj_consume_token(-1);
29549 throw new ParseException();
29550 }
29551 }
29552 jj_consume_token(ON);
29553 switch (jj_nt.kind) {
29554 case DATABASE:
29555 jj_consume_token(DATABASE);
29556 break;
29557 case REPLACE:
29558 case DEFINER:
29559 case CURRENT_USER:
29560 case SERIALLY_REUSABLE:
29561 case RESTRICT_REFERENCES:
29562 case EXCEPTION_INIT:
29563 case AUTONOMOUS_TRANSACTION:
29564 case LANGUAGE:
29565 case INLINE:
29566 case ADD:
29567 case AGGREGATE:
29568 case ALL:
29569 case ALTER:
29570 case AND:
29571 case ANY:
29572 case ARRAY:
29573 case AS:
29574 case ASC:
29575 case AT:
29576 case ATTRIBUTE:
29577 case AUTHID:
29578 case AVG:
29579 case BETWEEN:
29580 case BINARY_INTEGER:
29581 case BODY:
29582 case BOOLEAN:
29583 case BULK:
29584 case BY:
29585 case BYTE:
29586 case CASCADE:
29587 case CASE:
29588 case CHAR:
29589 case CHAR_BASE:
29590 case CHECK:
29591 case CLOSE:
29592 case CLUSTER:
29593 case COALESCE:
29594 case COLLECT:
29595 case COLUMN:
29596 case COMMENT:
29597 case COMMIT:
29598 case COMPRESS:
29599 case CONNECT:
29600 case CONSTANT:
29601 case CONSTRUCTOR:
29602 case CONTINUE:
29603 case CONVERT:
29604 case CREATE:
29605 case CURRENT:
29606 case CURRVAL:
29607 case CURSOR:
29608 case DATA:
29609 case DATE:
29610 case DAY:
29611 case DECLARE:
29612 case DECIMAL:
29613 case _DEFAULT:
29614 case DELETE:
29615 case DESC:
29616 case DISABLE:
29617 case DISTINCT:
29618 case DO:
29619 case DROP:
29620 case EDITIONABLE:
29621 case ELEMENT:
29622 case ELSE:
29623 case ELSIF:
29624 case ENABLE:
29625 case ESCAPE:
29626 case EXCEPT:
29627 case EXCEPTION:
29628 case EXCEPTIONS:
29629 case EXCLUSIVE:
29630 case EXECUTE:
29631 case EXISTS:
29632 case EXIT:
29633 case EXTERNAL:
29634 case EXTENDS:
29635 case EXTRACT:
29636 case FALSE:
29637 case FETCH:
29638 case FINAL:
29639 case FLOAT:
29640 case FOR:
29641 case FORALL:
29642 case FORCE:
29643 case FROM:
29644 case FUNCTION:
29645 case GLOBAL:
29646 case GOTO:
29647 case GROUP:
29648 case HASH:
29649 case HAVING:
29650 case HEAP:
29651 case HOUR:
29652 case IF:
29653 case IMMEDIATE:
29654 case IN:
29655 case INDEX:
29656 case INDICES:
29657 case INDEXTYPE:
29658 case INDICATOR:
29659 case INSERT:
29660 case INSTANTIABLE:
29661 case INTEGER:
29662 case INTERFACE:
29663 case INTERSECT:
29664 case INTERVAL:
29665 case INTO:
29666 case INVALIDATE:
29667 case IS:
29668 case ISOLATION:
29669 case JAVA:
29670 case LEVEL:
29671 case LIKE:
29672 case LIMIT:
29673 case LIMITED:
29674 case LOCK:
29675 case LONG:
29676 case LOOP:
29677 case MAP:
29678 case MAX:
29679 case MEMBER:
29680 case MERGE:
29681 case MIN:
29682 case MINUS:
29683 case MINUTE:
29684 case MLSLABEL:
29685 case MODIFY:
29686 case MOD:
29687 case MODE:
29688 case MONTH:
29689 case NATURAL:
29690 case NATURALN:
29691 case NEW:
29692 case NEXTVAL:
29693 case NO:
29694 case NOCOPY:
29695 case NONEDITIONABLE:
29696 case NOT:
29697 case NOWAIT:
29698 case NULL:
29699 case NULLIF:
29700 case NUMBER:
29701 case BFILE_BASE:
29702 case BLOB_BASE:
29703 case CLOB_BASE:
29704 case DATE_BASE:
29705 case NUMBER_BASE:
29706 case OBJECT:
29707 case OCIROWID:
29708 case OF:
29709 case OID:
29710 case ON:
29711 case OPAQUE:
29712 case OPEN:
29713 case OPERATOR:
29714 case OPTION:
29715 case OR:
29716 case ORDER:
29717 case ORGANIZATION:
29718 case OTHERS:
29719 case OUT:
29720 case OVERRIDING:
29721 case PACKAGE:
29722 case PARTITION:
29723 case PCTFREE:
29724 case PLS_INTEGER:
29725 case POSITIVE:
29726 case POSITIVEN:
29727 case PRESERVE:
29728 case PRIOR:
29729 case PROMPT:
29730 case PRIVATE:
29731 case PROCEDURE:
29732 case PUBLIC:
29733 case RAISE:
29734 case RANGE:
29735 case RAW:
29736 case REAL:
29737 case RECORD:
29738 case REF:
29739 case RELEASE:
29740 case RELIES_ON:
29741 case RENAME:
29742 case RESULT:
29743 case RETURN:
29744 case RETURNING:
29745 case REVERSE:
29746 case ROLLBACK:
29747 case ROW:
29748 case ROWS:
29749 case ROWID:
29750 case ROWNUM:
29751 case ROWTYPE:
29752 case SAVE:
29753 case SAVEPOINT:
29754 case SECOND:
29755 case SELECT:
29756 case SELF:
29757 case SEPARATE:
29758 case SET:
29759 case SHARE:
29760 case SMALLINT:
29761 case SPACE:
29762 case SQL:
29763 case SQLCODE:
29764 case SQLERRM:
29765 case START:
29766 case STATIC:
29767 case STDDEV:
29768 case SUBTYPE:
29769 case SUBSTITUTABLE:
29770 case SUCCESSFUL:
29771 case SUM:
29772 case SYNONYM:
29773 case SYSDATE:
29774 case SYS_REFCURSOR:
29775 case TABLE:
29776 case TEMPORARY:
29777 case THEN:
29778 case TIME:
29779 case TIMESTAMP:
29780 case TIMEZONE_REGION:
29781 case TIMEZONE_ABBR:
29782 case TIMEZONE_MINUTE:
29783 case TIMEZONE_HOUR:
29784 case TO:
29785 case TRANSACTION:
29786 case TRIGGER:
29787 case TRUE:
29788 case TYPE:
29789 case UI:
29790 case UNDER:
29791 case USING:
29792 case WHILE:
29793 case YES:
29794 case SHOW:
29795 case A:
29796 case UPDATE:
29797 case VARCHAR:
29798 case VARCHAR2:
29799 case DOUBLE:
29800 case DEC:
29801 case PRECISION:
29802 case INT:
29803 case NUMERIC:
29804 case SIGNTYPE:
29805 case NCHAR:
29806 case NVARCHAR2:
29807 case STRING:
29808 case UROWID:
29809 case VARRAY:
29810 case VARYING:
29811 case BFILE:
29812 case BLOB:
29813 case CLOB:
29814 case NCLOB:
29815 case YEAR:
29816 case LOCAL:
29817 case WITH:
29818 case ZONE:
29819 case CHARACTER:
29820 case AFTER:
29821 case BEFORE:
29822 case OLD:
29823 case PARENT:
29824 case ANALYZE:
29825 case ASSOCIATE:
29826 case AUDIT:
29827 case COMPOUND:
29828 case CALL:
29829 case DDL:
29830 case DISASSOCIATE:
29831 case EACH:
29832 case FOLLOWS:
29833 case LOGOFF:
29834 case LOGON:
29835 case NESTED:
29836 case NOAUDIT:
29837 case SCHEMA:
29838 case SERVERERROR:
29839 case SHUTDOWN:
29840 case STARTUP:
29841 case STATEMENT:
29842 case STATISTICS:
29843 case SUSPEND:
29844 case TRUNCATE:
29845 case WRAPPED:
29846 case LIBRARY:
29847 case NAME:
29848 case STRUCT:
29849 case CONTEXT:
29850 case PARAMETERS:
29851 case LENGTH:
29852 case TDO:
29853 case MAXLEN:
29854 case CHARSETID:
29855 case CHARSETFORM:
29856 case ACCEPT:
29857 case ACCESSIBLE:
29858 case COPY:
29859 case DEFINE:
29860 case DISCONNECT:
29861 case HOST:
29862 case PRINT:
29863 case QUIT:
29864 case REMARK:
29865 case UNDEFINE:
29866 case VARIABLE:
29867 case WHENEVER:
29868 case ATTACH:
29869 case CAST:
29870 case TREAT:
29871 case TRIM:
29872 case LEFT:
29873 case RIGHT:
29874 case BOTH:
29875 case EMPTY:
29876 case MULTISET:
29877 case SUBMULTISET:
29878 case LEADING:
29879 case TRAILING:
29880 case CHAR_CS:
29881 case NCHAR_CS:
29882 case DBTIMEZONE:
29883 case SESSIONTIMEZONE:
29884 case AUTHENTICATED:
29885 case LINK:
29886 case SHARED:
29887 case DIRECTORY:
29888 case USER:
29889 case IDENTIFIER:
29890 case QUOTED_LITERAL:
29891 case SQLDATA_CLASS:
29892 case CUSTOMDATUM_CLASS:
29893 case ORADATA_CLASS:
29894 case JAVA_INTERFACE_CLASS:
29895 if (jj_2_85(2)) {
29896 ID();
29897 jj_consume_token(3);
29898 } else {
29899 ;
29900 }
29901 jj_consume_token(SCHEMA);
29902 break;
29903 default:
29904 jj_la1[449] = jj_gen;
29905 jj_consume_token(-1);
29906 throw new ParseException();
29907 }
29908 jjtree.closeNodeScope(jjtn000, true);
29909 jjtc000 = false;
29910 {if (true) return jjtn000 ;}
29911 } catch (Throwable jjte000) {
29912 if (jjtc000) {
29913 jjtree.clearNodeScope(jjtn000);
29914 jjtc000 = false;
29915 } else {
29916 jjtree.popNode();
29917 }
29918 if (jjte000 instanceof RuntimeException) {
29919 {if (true) throw (RuntimeException)jjte000;}
29920 }
29921 if (jjte000 instanceof ParseException) {
29922 {if (true) throw (ParseException)jjte000;}
29923 }
29924 {if (true) throw (Error)jjte000;}
29925 } finally {
29926 if (jjtc000) {
29927 jjtree.closeNodeScope(jjtn000, true);
29928 }
29929 }
29930 throw new Error("Missing return statement in function");
29931 }
29932
29933 final public ASTDDLEvent DDLEvent() throws ParseException {
29934
29935 ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29936 boolean jjtc000 = true;
29937 jjtree.openNodeScope(jjtn000);
29938 try {
29939 switch (jj_nt.kind) {
29940 case ALTER:
29941 jj_consume_token(ALTER);
29942 break;
29943 case ANALYZE:
29944 jj_consume_token(ANALYZE);
29945 break;
29946 case ASSOCIATE:
29947 jj_consume_token(ASSOCIATE);
29948 jj_consume_token(STATISTICS);
29949 break;
29950 case AUDIT:
29951 jj_consume_token(AUDIT);
29952 break;
29953 case COMMENT:
29954 jj_consume_token(COMMENT);
29955 break;
29956 case CREATE:
29957 jj_consume_token(CREATE);
29958 break;
29959 case DISASSOCIATE:
29960 jj_consume_token(DISASSOCIATE);
29961 jj_consume_token(STATISTICS);
29962 break;
29963 case DROP:
29964 jj_consume_token(DROP);
29965 break;
29966 case GRANT:
29967 jj_consume_token(GRANT);
29968 break;
29969 case NOAUDIT:
29970 jj_consume_token(NOAUDIT);
29971 break;
29972 case RENAME:
29973 jj_consume_token(RENAME);
29974 break;
29975 case REVOKE:
29976 jj_consume_token(REVOKE);
29977 break;
29978 case TRUNCATE:
29979 jj_consume_token(TRUNCATE);
29980 break;
29981 case DDL:
29982 jj_consume_token(DDL);
29983 break;
29984 default:
29985 jj_la1[450] = jj_gen;
29986 jj_consume_token(-1);
29987 throw new ParseException();
29988 }
29989 jjtree.closeNodeScope(jjtn000, true);
29990 jjtc000 = false;
29991 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29992 } finally {
29993 if (jjtc000) {
29994 jjtree.closeNodeScope(jjtn000, true);
29995 }
29996 }
29997 throw new Error("Missing return statement in function");
29998 }
29999
30000 final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
30001
30002 ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
30003 boolean jjtc000 = true;
30004 jjtree.openNodeScope(jjtn000);
30005 try {
30006 switch (jj_nt.kind) {
30007 case STARTUP:
30008 jj_consume_token(STARTUP);
30009 break;
30010 case SHUTDOWN:
30011 jj_consume_token(SHUTDOWN);
30012 break;
30013 case LOGON:
30014 jj_consume_token(LOGON);
30015 break;
30016 case LOGOFF:
30017 jj_consume_token(LOGOFF);
30018 break;
30019 case SERVERERROR:
30020 jj_consume_token(SERVERERROR);
30021 break;
30022 case SUSPEND:
30023 jj_consume_token(SUSPEND);
30024 break;
30025 default:
30026 jj_la1[451] = jj_gen;
30027 jj_consume_token(-1);
30028 throw new ParseException();
30029 }
30030 jjtree.closeNodeScope(jjtn000, true);
30031 jjtc000 = false;
30032 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30033 } finally {
30034 if (jjtc000) {
30035 jjtree.closeNodeScope(jjtn000, true);
30036 }
30037 }
30038 throw new Error("Missing return statement in function");
30039 }
30040
30041 final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
30042
30043 ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
30044 boolean jjtc000 = true;
30045 jjtree.openNodeScope(jjtn000);
30046 try {
30047 switch (jj_nt.kind) {
30048 case ALTER:
30049 case COMMENT:
30050 case CREATE:
30051 case DROP:
30052 case GRANT:
30053 case RENAME:
30054 case REVOKE:
30055 case ANALYZE:
30056 case ASSOCIATE:
30057 case AUDIT:
30058 case DDL:
30059 case DISASSOCIATE:
30060 case NOAUDIT:
30061 case TRUNCATE:
30062 DDLEvent();
30063 break;
30064 case LOGOFF:
30065 case LOGON:
30066 case SERVERERROR:
30067 case SHUTDOWN:
30068 case STARTUP:
30069 case SUSPEND:
30070 DatabaseEvent();
30071 break;
30072 default:
30073 jj_la1[452] = jj_gen;
30074 jj_consume_token(-1);
30075 throw new ParseException();
30076 }
30077 jjtree.closeNodeScope(jjtn000, true);
30078 jjtc000 = false;
30079 {if (true) return jjtn000;}
30080 } catch (Throwable jjte000) {
30081 if (jjtc000) {
30082 jjtree.clearNodeScope(jjtn000);
30083 jjtc000 = false;
30084 } else {
30085 jjtree.popNode();
30086 }
30087 if (jjte000 instanceof RuntimeException) {
30088 {if (true) throw (RuntimeException)jjte000;}
30089 }
30090 if (jjte000 instanceof ParseException) {
30091 {if (true) throw (ParseException)jjte000;}
30092 }
30093 {if (true) throw (Error)jjte000;}
30094 } finally {
30095 if (jjtc000) {
30096 jjtree.closeNodeScope(jjtn000, true);
30097 }
30098 }
30099 throw new Error("Missing return statement in function");
30100 }
30101
30102
30103
30104
30105
30106
30107
30108
30109 final public void AlterTrigger() throws ParseException {
30110
30111 ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
30112 boolean jjtc000 = true;
30113 jjtree.openNodeScope(jjtn000);
30114 try {
30115 jj_consume_token(ALTER);
30116 jj_consume_token(TRIGGER);
30117 Skip2NextTerminator(null,";");
30118 jj_consume_token(4);
30119 jjtree.closeNodeScope(jjtn000, true);
30120 jjtc000 = false;
30121 {if (true) return;}
30122 } catch (Throwable jjte000) {
30123 if (jjtc000) {
30124 jjtree.clearNodeScope(jjtn000);
30125 jjtc000 = false;
30126 } else {
30127 jjtree.popNode();
30128 }
30129 if (jjte000 instanceof RuntimeException) {
30130 {if (true) throw (RuntimeException)jjte000;}
30131 }
30132 if (jjte000 instanceof ParseException) {
30133 {if (true) throw (ParseException)jjte000;}
30134 }
30135 {if (true) throw (Error)jjte000;}
30136 } finally {
30137 if (jjtc000) {
30138 jjtree.closeNodeScope(jjtn000, true);
30139 }
30140 }
30141 }
30142
30143
30144 final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
30145
30146 ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
30147 boolean jjtc000 = true;
30148 jjtree.openNodeScope(jjtn000);
30149 try {
30150 switch (jj_nt.kind) {
30151 case ALL:
30152 jj_consume_token(ALL);
30153 break;
30154 case ALTER:
30155 jj_consume_token(ALTER);
30156 break;
30157 case AND:
30158 jj_consume_token(AND);
30159 break;
30160 case ANY:
30161 jj_consume_token(ANY);
30162 break;
30163 case AS:
30164 jj_consume_token(AS);
30165 break;
30166 case ASC:
30167 jj_consume_token(ASC);
30168 break;
30169 case BETWEEN:
30170 jj_consume_token(BETWEEN);
30171 break;
30172 case BY:
30173 jj_consume_token(BY);
30174 break;
30175 case CHAR:
30176 jj_consume_token(CHAR);
30177 break;
30178 case CHECK:
30179 jj_consume_token(CHECK);
30180 break;
30181 case CLUSTER:
30182 jj_consume_token(CLUSTER);
30183 break;
30184 case COMPRESS:
30185 jj_consume_token(COMPRESS);
30186 break;
30187 case CONNECT:
30188 jj_consume_token(CONNECT);
30189 break;
30190 case CREATE:
30191 jj_consume_token(CREATE);
30192 break;
30193 case DATE:
30194 jj_consume_token(DATE);
30195 break;
30196 case DECIMAL:
30197 jj_consume_token(DECIMAL);
30198 break;
30199 case _DEFAULT:
30200 jj_consume_token(_DEFAULT);
30201 break;
30202 case DELETE:
30203 jj_consume_token(DELETE);
30204 break;
30205 case DESC:
30206 jj_consume_token(DESC);
30207 break;
30208 case DISTINCT:
30209 jj_consume_token(DISTINCT);
30210 break;
30211 case DROP:
30212 jj_consume_token(DROP);
30213 break;
30214 case ELSE:
30215 jj_consume_token(ELSE);
30216 break;
30217 case EXCLUSIVE:
30218 jj_consume_token(EXCLUSIVE);
30219 break;
30220 case EXISTS:
30221 jj_consume_token(EXISTS);
30222 break;
30223 case FLOAT:
30224 jj_consume_token(FLOAT);
30225 break;
30226 case FOR:
30227 jj_consume_token(FOR);
30228 break;
30229 case FROM:
30230 jj_consume_token(FROM);
30231 break;
30232 case GRANT:
30233 jj_consume_token(GRANT);
30234 break;
30235 case GROUP:
30236 jj_consume_token(GROUP);
30237 break;
30238 case HAVING:
30239 jj_consume_token(HAVING);
30240 break;
30241 case IDENTIFIED:
30242 jj_consume_token(IDENTIFIED);
30243 break;
30244 case IN:
30245 jj_consume_token(IN);
30246 break;
30247 case INDEX:
30248 jj_consume_token(INDEX);
30249 break;
30250 case INSERT:
30251 jj_consume_token(INSERT);
30252 break;
30253 case INTEGER:
30254 jj_consume_token(INTEGER);
30255 break;
30256 case INTERSECT:
30257 jj_consume_token(INTERSECT);
30258 break;
30259 case INTO:
30260 jj_consume_token(INTO);
30261 break;
30262 case IS:
30263 jj_consume_token(IS);
30264 break;
30265 case LIKE:
30266 jj_consume_token(LIKE);
30267 break;
30268 case LOCK:
30269 jj_consume_token(LOCK);
30270 break;
30271 case LONG:
30272 jj_consume_token(LONG);
30273 break;
30274 case MINUS:
30275 jj_consume_token(MINUS);
30276 break;
30277 case MODE:
30278 jj_consume_token(MODE);
30279 break;
30280 case NOCOMPRESS:
30281 jj_consume_token(NOCOMPRESS);
30282 break;
30283 case NOT:
30284 jj_consume_token(NOT);
30285 break;
30286 case NOWAIT:
30287 jj_consume_token(NOWAIT);
30288 break;
30289 case NULL:
30290 jj_consume_token(NULL);
30291 break;
30292 case NUMBER:
30293 jj_consume_token(NUMBER);
30294 break;
30295 case OF:
30296 jj_consume_token(OF);
30297 break;
30298 case ON:
30299 jj_consume_token(ON);
30300 break;
30301 case OPTION:
30302 jj_consume_token(OPTION);
30303 break;
30304 case OR:
30305 jj_consume_token(OR);
30306 break;
30307 case ORDER:
30308 jj_consume_token(ORDER);
30309 break;
30310 case PCTFREE:
30311 jj_consume_token(PCTFREE);
30312 break;
30313 case PRIOR:
30314 jj_consume_token(PRIOR);
30315 break;
30316 case PUBLIC:
30317 jj_consume_token(PUBLIC);
30318 break;
30319 case RAW:
30320 jj_consume_token(RAW);
30321 break;
30322 case RESOURCE:
30323 jj_consume_token(RESOURCE);
30324 break;
30325 case REVOKE:
30326 jj_consume_token(REVOKE);
30327 break;
30328 case SELECT:
30329 jj_consume_token(SELECT);
30330 break;
30331 case SET:
30332 jj_consume_token(SET);
30333 break;
30334 case SHARE:
30335 jj_consume_token(SHARE);
30336 break;
30337 case SIZE:
30338 jj_consume_token(SIZE);
30339 break;
30340 case SMALLINT:
30341 jj_consume_token(SMALLINT);
30342 break;
30343 case START:
30344 jj_consume_token(START);
30345 break;
30346 case SYNONYM:
30347 jj_consume_token(SYNONYM);
30348 break;
30349 case TABLE:
30350 jj_consume_token(TABLE);
30351 break;
30352 case THEN:
30353 jj_consume_token(THEN);
30354 break;
30355 case TO:
30356 jj_consume_token(TO);
30357 break;
30358 case TRIGGER:
30359 jj_consume_token(TRIGGER);
30360 break;
30361 case UNION:
30362 jj_consume_token(UNION);
30363 break;
30364 case UNIQUE:
30365 jj_consume_token(UNIQUE);
30366 break;
30367 case UPDATE:
30368 jj_consume_token(UPDATE);
30369 break;
30370 case VALUES:
30371 jj_consume_token(VALUES);
30372 break;
30373 case VARCHAR:
30374 jj_consume_token(VARCHAR);
30375 break;
30376 case VARCHAR2:
30377 jj_consume_token(VARCHAR2);
30378 break;
30379 case VIEW:
30380 jj_consume_token(VIEW);
30381 break;
30382 case WHERE:
30383 jj_consume_token(WHERE);
30384 break;
30385 case WITH:
30386 jj_consume_token(WITH);
30387 break;
30388 default:
30389 jj_la1[453] = jj_gen;
30390 jj_consume_token(-1);
30391 throw new ParseException();
30392 }
30393 jjtree.closeNodeScope(jjtn000, true);
30394 jjtc000 = false;
30395 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30396 } finally {
30397 if (jjtc000) {
30398 jjtree.closeNodeScope(jjtn000, true);
30399 }
30400 }
30401 throw new Error("Missing return statement in function");
30402 }
30403
30404 final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
30405
30406 ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
30407 boolean jjtc000 = true;
30408 jjtree.openNodeScope(jjtn000);
30409 try {
30410 switch (jj_nt.kind) {
30411 case FALSE:
30412 jj_consume_token(FALSE);
30413 break;
30414 case TRUE:
30415 jj_consume_token(TRUE);
30416 break;
30417 case A:
30418 jj_consume_token(A);
30419 break;
30420 case ACCEPT:
30421 jj_consume_token(ACCEPT);
30422 break;
30423 case ADD:
30424 jj_consume_token(ADD);
30425 break;
30426 case AFTER:
30427 jj_consume_token(AFTER);
30428 break;
30429 case AGGREGATE:
30430 jj_consume_token(AGGREGATE);
30431 break;
30432 case ANALYZE:
30433 jj_consume_token(ANALYZE);
30434 break;
30435 case ASSOCIATE:
30436 jj_consume_token(ASSOCIATE);
30437 break;
30438 case AT:
30439 jj_consume_token(AT);
30440 break;
30441 case ATTACH:
30442 jj_consume_token(ATTACH);
30443 break;
30444 case ATTRIBUTE:
30445 jj_consume_token(ATTRIBUTE);
30446 break;
30447 case AUDIT:
30448 jj_consume_token(AUDIT);
30449 break;
30450 case AUTHENTICATED:
30451 jj_consume_token(AUTHENTICATED);
30452 break;
30453 case AUTHID:
30454 jj_consume_token(AUTHID);
30455 break;
30456 case BEFORE:
30457 jj_consume_token(BEFORE);
30458 break;
30459 case BFILE:
30460 jj_consume_token(BFILE);
30461 break;
30462 case BLOB:
30463 jj_consume_token(BLOB);
30464 break;
30465 case BOTH:
30466 jj_consume_token(BOTH);
30467 break;
30468 case BULK:
30469 jj_consume_token(BULK);
30470 break;
30471 case BYTE:
30472 jj_consume_token(BYTE);
30473 break;
30474 case CALL:
30475 jj_consume_token(CALL);
30476 break;
30477 case CASCADE:
30478 jj_consume_token(CASCADE);
30479 break;
30480 case CAST:
30481 jj_consume_token(CAST);
30482 break;
30483 case CHAR_CS:
30484 jj_consume_token(CHAR_CS);
30485 break;
30486 case CHARACTER:
30487 jj_consume_token(CHARACTER);
30488 break;
30489 case CHARSETFORM:
30490 jj_consume_token(CHARSETFORM);
30491 break;
30492 case CHARSETID:
30493 jj_consume_token(CHARSETID);
30494 break;
30495 case CLOB:
30496 jj_consume_token(CLOB);
30497 break;
30498 case CLOSE:
30499 jj_consume_token(CLOSE);
30500 break;
30501 case COALESCE:
30502 jj_consume_token(COALESCE);
30503 break;
30504 case COLLECT:
30505 jj_consume_token(COLLECT);
30506 break;
30507 case COLUMN:
30508 jj_consume_token(COLUMN);
30509 break;
30510 case COMMENT:
30511 jj_consume_token(COMMENT);
30512 break;
30513 case COMMIT:
30514 jj_consume_token(COMMIT);
30515 break;
30516 case COMPOUND:
30517 jj_consume_token(COMPOUND);
30518 break;
30519 case CONSTRUCTOR:
30520 jj_consume_token(CONSTRUCTOR);
30521 break;
30522 case CONTEXT:
30523 jj_consume_token(CONTEXT);
30524 break;
30525 case CONTINUE:
30526 jj_consume_token(CONTINUE);
30527 break;
30528 case CONVERT:
30529 jj_consume_token(CONVERT);
30530 break;
30531 case COPY:
30532 jj_consume_token(COPY);
30533 break;
30534 case CURRENT:
30535 jj_consume_token(CURRENT);
30536 break;
30537 case CURRENT_USER:
30538 jj_consume_token(CURRENT_USER);
30539 break;
30540 case CURSOR:
30541 jj_consume_token(CURSOR);
30542 break;
30543 case DATA:
30544 jj_consume_token(DATA);
30545 break;
30546 case DATABASE:
30547 jj_consume_token(DATABASE);
30548 break;
30549 case DAY:
30550 jj_consume_token(DAY);
30551 break;
30552 case DBTIMEZONE:
30553 jj_consume_token(DBTIMEZONE);
30554 break;
30555 case DDL:
30556 jj_consume_token(DDL);
30557 break;
30558 case DEC:
30559 jj_consume_token(DEC);
30560 break;
30561 case DEFINE:
30562 jj_consume_token(DEFINE);
30563 break;
30564 case DEFINER:
30565 jj_consume_token(DEFINER);
30566 break;
30567 case DIRECTORY:
30568 jj_consume_token(DIRECTORY);
30569 break;
30570 case DISABLE:
30571 jj_consume_token(DISABLE);
30572 break;
30573 case DISASSOCIATE:
30574 jj_consume_token(DISASSOCIATE);
30575 break;
30576 case DISCONNECT:
30577 jj_consume_token(DISCONNECT);
30578 break;
30579 case DOUBLE:
30580 jj_consume_token(DOUBLE);
30581 break;
30582 case EACH:
30583 jj_consume_token(EACH);
30584 break;
30585 case ELEMENT:
30586 jj_consume_token(ELEMENT);
30587 break;
30588 case EMPTY:
30589 jj_consume_token(EMPTY);
30590 break;
30591 case ENABLE:
30592 jj_consume_token(ENABLE);
30593 break;
30594 case ESCAPE:
30595 jj_consume_token(ESCAPE);
30596 break;
30597 case EXCEPT:
30598 jj_consume_token(EXCEPT);
30599 break;
30600 case EXCEPTIONS:
30601 jj_consume_token(EXCEPTIONS);
30602 break;
30603 case EXIT:
30604 jj_consume_token(EXIT);
30605 break;
30606 case EXTENDS:
30607 jj_consume_token(EXTENDS);
30608 break;
30609 case EXTERNAL:
30610 jj_consume_token(EXTERNAL);
30611 break;
30612 case EXTRACT:
30613 jj_consume_token(EXTRACT);
30614 break;
30615 case FINAL:
30616 jj_consume_token(FINAL);
30617 break;
30618 case FOLLOWS:
30619 jj_consume_token(FOLLOWS);
30620 break;
30621 case FORCE:
30622 jj_consume_token(FORCE);
30623 break;
30624 case FUNCTION:
30625 jj_consume_token(FUNCTION);
30626 break;
30627 case GLOBAL:
30628 jj_consume_token(GLOBAL);
30629 break;
30630 case HASH:
30631 jj_consume_token(HASH);
30632 break;
30633 case HEAP:
30634 jj_consume_token(HEAP);
30635 break;
30636 case HOST:
30637 jj_consume_token(HOST);
30638 break;
30639 case HOUR:
30640 jj_consume_token(HOUR);
30641 break;
30642 case IMMEDIATE:
30643 jj_consume_token(IMMEDIATE);
30644 break;
30645 case INDEXTYPE:
30646 jj_consume_token(INDEXTYPE);
30647 break;
30648 case INDICATOR:
30649 jj_consume_token(INDICATOR);
30650 break;
30651 case INDICES:
30652 jj_consume_token(INDICES);
30653 break;
30654 case INSTANTIABLE:
30655 jj_consume_token(INSTANTIABLE);
30656 break;
30657 case INTERVAL:
30658 jj_consume_token(INTERVAL);
30659 break;
30660 case INVALIDATE:
30661 jj_consume_token(INVALIDATE);
30662 break;
30663 case ISOLATION:
30664 jj_consume_token(ISOLATION);
30665 break;
30666 case JAVA:
30667 jj_consume_token(JAVA);
30668 break;
30669 case LANGUAGE:
30670 jj_consume_token(LANGUAGE);
30671 break;
30672 case LEADING:
30673 jj_consume_token(LEADING);
30674 break;
30675 case LEFT:
30676 jj_consume_token(LEFT);
30677 break;
30678 case LENGTH:
30679 jj_consume_token(LENGTH);
30680 break;
30681 case LEVEL:
30682 jj_consume_token(LEVEL);
30683 break;
30684 case LIBRARY:
30685 jj_consume_token(LIBRARY);
30686 break;
30687 case LIMIT:
30688 jj_consume_token(LIMIT);
30689 break;
30690 case LINK:
30691 jj_consume_token(LINK);
30692 break;
30693 case LOCAL:
30694 jj_consume_token(LOCAL);
30695 break;
30696 case LOGOFF:
30697 jj_consume_token(LOGOFF);
30698 break;
30699 case LOGON:
30700 jj_consume_token(LOGON);
30701 break;
30702 case MAP:
30703 jj_consume_token(MAP);
30704 break;
30705 case MAX:
30706 jj_consume_token(MAX);
30707 break;
30708 case MAXLEN:
30709 jj_consume_token(MAXLEN);
30710 break;
30711 case MEMBER:
30712 jj_consume_token(MEMBER);
30713 break;
30714 case MERGE:
30715 jj_consume_token(MERGE);
30716 break;
30717 case MIN:
30718 jj_consume_token(MIN);
30719 break;
30720 case MINUTE:
30721 jj_consume_token(MINUTE);
30722 break;
30723 case MLSLABEL:
30724 jj_consume_token(MLSLABEL);
30725 break;
30726 case MODIFY:
30727 jj_consume_token(MODIFY);
30728 break;
30729 case MONTH:
30730 jj_consume_token(MONTH);
30731 break;
30732 case MULTISET:
30733 jj_consume_token(MULTISET);
30734 break;
30735 case NAME:
30736 jj_consume_token(NAME);
30737 break;
30738 case NATURAL:
30739 jj_consume_token(NATURAL);
30740 break;
30741 case NCHAR:
30742 jj_consume_token(NCHAR);
30743 break;
30744 case NCHAR_CS:
30745 jj_consume_token(NCHAR_CS);
30746 break;
30747 case NCLOB:
30748 jj_consume_token(NCLOB);
30749 break;
30750 case NESTED:
30751 jj_consume_token(NESTED);
30752 break;
30753 case NEW:
30754 jj_consume_token(NEW);
30755 break;
30756 case NO:
30757 jj_consume_token(NO);
30758 break;
30759 case NOAUDIT:
30760 jj_consume_token(NOAUDIT);
30761 break;
30762 case NUMERIC:
30763 jj_consume_token(NUMERIC);
30764 break;
30765 case NVARCHAR2:
30766 jj_consume_token(NVARCHAR2);
30767 break;
30768 case OBJECT:
30769 jj_consume_token(OBJECT);
30770 break;
30771 case OID:
30772 jj_consume_token(OID);
30773 break;
30774 case OLD:
30775 jj_consume_token(OLD);
30776 break;
30777 case OPAQUE:
30778 jj_consume_token(OPAQUE);
30779 break;
30780 case OPEN:
30781 jj_consume_token(OPEN);
30782 break;
30783 case ORGANIZATION:
30784 jj_consume_token(ORGANIZATION);
30785 break;
30786 case OTHERS:
30787 jj_consume_token(OTHERS);
30788 break;
30789 case OVERRIDING:
30790 jj_consume_token(OVERRIDING);
30791 break;
30792 case PACKAGE:
30793 jj_consume_token(PACKAGE);
30794 break;
30795 case PARAMETERS:
30796 jj_consume_token(PARAMETERS);
30797 break;
30798 case PARENT:
30799 jj_consume_token(PARENT);
30800 break;
30801 case PARTITION:
30802 jj_consume_token(PARTITION);
30803 break;
30804 case PRECISION:
30805 jj_consume_token(PRECISION);
30806 break;
30807 case PRESERVE:
30808 jj_consume_token(PRESERVE);
30809 break;
30810 case PRINT:
30811 jj_consume_token(PRINT);
30812 break;
30813 case PROCEDURE:
30814 jj_consume_token(PROCEDURE);
30815 break;
30816 case QUIT:
30817 jj_consume_token(QUIT);
30818 break;
30819 case RANGE:
30820 jj_consume_token(RANGE);
30821 break;
30822 case REAL:
30823 jj_consume_token(REAL);
30824 break;
30825 case RECORD:
30826 jj_consume_token(RECORD);
30827 break;
30828 case REF:
30829 jj_consume_token(REF);
30830 break;
30831 case RELIES_ON:
30832 jj_consume_token(RELIES_ON);
30833 break;
30834 case REMARK:
30835 jj_consume_token(REMARK);
30836 break;
30837 case RESULT:
30838 jj_consume_token(RESULT);
30839 break;
30840 case RETURN:
30841 jj_consume_token(RETURN);
30842 break;
30843 case RETURNING:
30844 jj_consume_token(RETURNING);
30845 break;
30846 case REVERSE:
30847 jj_consume_token(REVERSE);
30848 break;
30849 case RIGHT:
30850 jj_consume_token(RIGHT);
30851 break;
30852 case ROLLBACK:
30853 jj_consume_token(ROLLBACK);
30854 break;
30855 case ROW:
30856 jj_consume_token(ROW);
30857 break;
30858 case ROWID:
30859 jj_consume_token(ROWID);
30860 break;
30861 case ROWNUM:
30862 jj_consume_token(ROWNUM);
30863 break;
30864 case ROWS:
30865 jj_consume_token(ROWS);
30866 break;
30867 case SAVE:
30868 jj_consume_token(SAVE);
30869 break;
30870 case SAVEPOINT:
30871 jj_consume_token(SAVEPOINT);
30872 break;
30873 case SCHEMA:
30874 jj_consume_token(SCHEMA);
30875 break;
30876 case SECOND:
30877 jj_consume_token(SECOND);
30878 break;
30879 case SELF:
30880 jj_consume_token(SELF);
30881 break;
30882 case SERVERERROR:
30883 jj_consume_token(SERVERERROR);
30884 break;
30885 case SESSIONTIMEZONE:
30886 jj_consume_token(SESSIONTIMEZONE);
30887 break;
30888 case SET:
30889 jj_consume_token(SET);
30890 break;
30891 case SHARED:
30892 jj_consume_token(SHARED);
30893 break;
30894 case SHUTDOWN:
30895 jj_consume_token(SHUTDOWN);
30896 break;
30897 case SPACE:
30898 jj_consume_token(SPACE);
30899 break;
30900 case STARTUP:
30901 jj_consume_token(STARTUP);
30902 break;
30903 case STATEMENT:
30904 jj_consume_token(STATEMENT);
30905 break;
30906 case STATIC:
30907 jj_consume_token(STATIC);
30908 break;
30909 case STATISTICS:
30910 jj_consume_token(STATISTICS);
30911 break;
30912 case STRUCT:
30913 jj_consume_token(STRUCT);
30914 break;
30915 case SUBMULTISET:
30916 jj_consume_token(SUBMULTISET);
30917 break;
30918 case SUBSTITUTABLE:
30919 jj_consume_token(SUBSTITUTABLE);
30920 break;
30921 case SUBTYPE:
30922 jj_consume_token(SUBTYPE);
30923 break;
30924 case SUCCESSFUL:
30925 jj_consume_token(SUCCESSFUL);
30926 break;
30927 case SUSPEND:
30928 jj_consume_token(SUSPEND);
30929 break;
30930 case TDO:
30931 jj_consume_token(TDO);
30932 break;
30933 case TEMPORARY:
30934 jj_consume_token(TEMPORARY);
30935 break;
30936 case TIME:
30937 jj_consume_token(TIME);
30938 break;
30939 case TIMESTAMP:
30940 jj_consume_token(TIMESTAMP);
30941 break;
30942 case TIMEZONE_ABBR:
30943 jj_consume_token(TIMEZONE_ABBR);
30944 break;
30945 case TIMEZONE_HOUR:
30946 jj_consume_token(TIMEZONE_HOUR);
30947 break;
30948 case TIMEZONE_MINUTE:
30949 jj_consume_token(TIMEZONE_MINUTE);
30950 break;
30951 case TIMEZONE_REGION:
30952 jj_consume_token(TIMEZONE_REGION);
30953 break;
30954 case TRAILING:
30955 jj_consume_token(TRAILING);
30956 break;
30957 case TRANSACTION:
30958 jj_consume_token(TRANSACTION);
30959 break;
30960 case TREAT:
30961 jj_consume_token(TREAT);
30962 break;
30963 case TRIM:
30964 jj_consume_token(TRIM);
30965 break;
30966 case TRUNCATE:
30967 jj_consume_token(TRUNCATE);
30968 break;
30969 case UNDEFINE:
30970 jj_consume_token(UNDEFINE);
30971 break;
30972 case UNDER:
30973 jj_consume_token(UNDER);
30974 break;
30975 case UROWID:
30976 jj_consume_token(UROWID);
30977 break;
30978 case USER:
30979 jj_consume_token(USER);
30980 break;
30981 case USING:
30982 jj_consume_token(USING);
30983 break;
30984 case VARRAY:
30985 jj_consume_token(VARRAY);
30986 break;
30987 case VARIABLE:
30988 jj_consume_token(VARIABLE);
30989 break;
30990 case VARYING:
30991 jj_consume_token(VARYING);
30992 break;
30993 case WHENEVER:
30994 jj_consume_token(WHENEVER);
30995 break;
30996 case YEAR:
30997 jj_consume_token(YEAR);
30998 break;
30999 case YES:
31000 jj_consume_token(YES);
31001 break;
31002 case ZONE:
31003 jj_consume_token(ZONE);
31004 break;
31005 case SHOW:
31006 jj_consume_token(SHOW);
31007 break;
31008 case WRAPPED:
31009 jj_consume_token(WRAPPED);
31010 break;
31011 case SYS_REFCURSOR:
31012 jj_consume_token(SYS_REFCURSOR);
31013 break;
31014 case EDITIONABLE:
31015 jj_consume_token(EDITIONABLE);
31016 break;
31017 case NONEDITIONABLE:
31018 jj_consume_token(NONEDITIONABLE);
31019 break;
31020 case ACCESSIBLE:
31021 jj_consume_token(ACCESSIBLE);
31022 break;
31023 case NULLIF:
31024 jj_consume_token(NULLIF);
31025 break;
31026 case RENAME:
31027 jj_consume_token(RENAME);
31028 break;
31029 case RELEASE:
31030 jj_consume_token(RELEASE);
31031 break;
31032 case INLINE:
31033 jj_consume_token(INLINE);
31034 break;
31035 default:
31036 jj_la1[454] = jj_gen;
31037 jj_consume_token(-1);
31038 throw new ParseException();
31039 }
31040 jjtree.closeNodeScope(jjtn000, true);
31041 jjtc000 = false;
31042 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31043 } finally {
31044 if (jjtc000) {
31045 jjtree.closeNodeScope(jjtn000, true);
31046 }
31047 }
31048 throw new Error("Missing return statement in function");
31049 }
31050
31051
31052
31053
31054
31055 final public ASTID ID() throws ParseException {
31056
31057 ASTID jjtn000 = new ASTID(this, JJTID);
31058 boolean jjtc000 = true;
31059 jjtree.openNodeScope(jjtn000);
31060 try {
31061 switch (jj_nt.kind) {
31062 case IDENTIFIER:
31063 jj_consume_token(IDENTIFIER);
31064 break;
31065 case QUOTED_LITERAL:
31066 jj_consume_token(QUOTED_LITERAL);
31067 break;
31068 case DEFINER:
31069 case CURRENT_USER:
31070 case LANGUAGE:
31071 case INLINE:
31072 case ADD:
31073 case AGGREGATE:
31074 case AT:
31075 case ATTRIBUTE:
31076 case AUTHID:
31077 case BULK:
31078 case BYTE:
31079 case CASCADE:
31080 case CLOSE:
31081 case COALESCE:
31082 case COLLECT:
31083 case COLUMN:
31084 case COMMENT:
31085 case COMMIT:
31086 case CONSTRUCTOR:
31087 case CONTINUE:
31088 case CONVERT:
31089 case CURRENT:
31090 case CURSOR:
31091 case DATA:
31092 case DAY:
31093 case DISABLE:
31094 case EDITIONABLE:
31095 case ELEMENT:
31096 case ENABLE:
31097 case ESCAPE:
31098 case EXCEPT:
31099 case EXCEPTIONS:
31100 case EXIT:
31101 case EXTERNAL:
31102 case EXTENDS:
31103 case EXTRACT:
31104 case FALSE:
31105 case FINAL:
31106 case FORCE:
31107 case FUNCTION:
31108 case GLOBAL:
31109 case HASH:
31110 case HEAP:
31111 case HOUR:
31112 case IMMEDIATE:
31113 case INDICES:
31114 case INDEXTYPE:
31115 case INDICATOR:
31116 case INSTANTIABLE:
31117 case INTERVAL:
31118 case INVALIDATE:
31119 case ISOLATION:
31120 case JAVA:
31121 case LEVEL:
31122 case LIMIT:
31123 case MAP:
31124 case MAX:
31125 case MEMBER:
31126 case MERGE:
31127 case MIN:
31128 case MINUTE:
31129 case MLSLABEL:
31130 case MODIFY:
31131 case MONTH:
31132 case NATURAL:
31133 case NEW:
31134 case NO:
31135 case NONEDITIONABLE:
31136 case NULLIF:
31137 case OBJECT:
31138 case OID:
31139 case OPAQUE:
31140 case OPEN:
31141 case ORGANIZATION:
31142 case OTHERS:
31143 case OVERRIDING:
31144 case PACKAGE:
31145 case PARTITION:
31146 case PRESERVE:
31147 case PROCEDURE:
31148 case RANGE:
31149 case REAL:
31150 case RECORD:
31151 case REF:
31152 case RELEASE:
31153 case RELIES_ON:
31154 case RENAME:
31155 case RESULT:
31156 case RETURN:
31157 case RETURNING:
31158 case REVERSE:
31159 case ROLLBACK:
31160 case ROW:
31161 case ROWS:
31162 case ROWID:
31163 case ROWNUM:
31164 case SAVE:
31165 case SAVEPOINT:
31166 case SECOND:
31167 case SELF:
31168 case SET:
31169 case SPACE:
31170 case STATIC:
31171 case SUBTYPE:
31172 case SUBSTITUTABLE:
31173 case SUCCESSFUL:
31174 case SYS_REFCURSOR:
31175 case TEMPORARY:
31176 case TIME:
31177 case TIMESTAMP:
31178 case TIMEZONE_REGION:
31179 case TIMEZONE_ABBR:
31180 case TIMEZONE_MINUTE:
31181 case TIMEZONE_HOUR:
31182 case TRANSACTION:
31183 case TRUE:
31184 case UNDER:
31185 case USING:
31186 case YES:
31187 case SHOW:
31188 case A:
31189 case DOUBLE:
31190 case DEC:
31191 case PRECISION:
31192 case NUMERIC:
31193 case NCHAR:
31194 case NVARCHAR2:
31195 case UROWID:
31196 case VARRAY:
31197 case VARYING:
31198 case BFILE:
31199 case BLOB:
31200 case CLOB:
31201 case NCLOB:
31202 case YEAR:
31203 case LOCAL:
31204 case ZONE:
31205 case CHARACTER:
31206 case AFTER:
31207 case BEFORE:
31208 case OLD:
31209 case PARENT:
31210 case ANALYZE:
31211 case ASSOCIATE:
31212 case AUDIT:
31213 case COMPOUND:
31214 case DATABASE:
31215 case CALL:
31216 case DDL:
31217 case DISASSOCIATE:
31218 case EACH:
31219 case FOLLOWS:
31220 case LOGOFF:
31221 case LOGON:
31222 case NESTED:
31223 case NOAUDIT:
31224 case SCHEMA:
31225 case SERVERERROR:
31226 case SHUTDOWN:
31227 case STARTUP:
31228 case STATEMENT:
31229 case STATISTICS:
31230 case SUSPEND:
31231 case TRUNCATE:
31232 case WRAPPED:
31233 case LIBRARY:
31234 case NAME:
31235 case STRUCT:
31236 case CONTEXT:
31237 case PARAMETERS:
31238 case LENGTH:
31239 case TDO:
31240 case MAXLEN:
31241 case CHARSETID:
31242 case CHARSETFORM:
31243 case ACCEPT:
31244 case ACCESSIBLE:
31245 case COPY:
31246 case DEFINE:
31247 case DISCONNECT:
31248 case HOST:
31249 case PRINT:
31250 case QUIT:
31251 case REMARK:
31252 case UNDEFINE:
31253 case VARIABLE:
31254 case WHENEVER:
31255 case ATTACH:
31256 case CAST:
31257 case TREAT:
31258 case TRIM:
31259 case LEFT:
31260 case RIGHT:
31261 case BOTH:
31262 case EMPTY:
31263 case MULTISET:
31264 case SUBMULTISET:
31265 case LEADING:
31266 case TRAILING:
31267 case CHAR_CS:
31268 case NCHAR_CS:
31269 case DBTIMEZONE:
31270 case SESSIONTIMEZONE:
31271 case AUTHENTICATED:
31272 case LINK:
31273 case SHARED:
31274 case DIRECTORY:
31275 case USER:
31276 KEYWORD_UNRESERVED();
31277 break;
31278 case REPLACE:
31279 jj_consume_token(REPLACE);
31280 break;
31281 case SERIALLY_REUSABLE:
31282 jj_consume_token(SERIALLY_REUSABLE);
31283 break;
31284 case RESTRICT_REFERENCES:
31285 jj_consume_token(RESTRICT_REFERENCES);
31286 break;
31287 case EXCEPTION_INIT:
31288 jj_consume_token(EXCEPTION_INIT);
31289 break;
31290 case AUTONOMOUS_TRANSACTION:
31291 jj_consume_token(AUTONOMOUS_TRANSACTION);
31292 break;
31293 case ALL:
31294 jj_consume_token(ALL);
31295 break;
31296 case ALTER:
31297 jj_consume_token(ALTER);
31298 break;
31299 case AND:
31300 jj_consume_token(AND);
31301 break;
31302 case ANY:
31303 jj_consume_token(ANY);
31304 break;
31305 case ARRAY:
31306 jj_consume_token(ARRAY);
31307 break;
31308 case AS:
31309 jj_consume_token(AS);
31310 break;
31311 case ASC:
31312 jj_consume_token(ASC);
31313 break;
31314 case AVG:
31315 jj_consume_token(AVG);
31316 break;
31317 case BETWEEN:
31318 jj_consume_token(BETWEEN);
31319 break;
31320 case BINARY_INTEGER:
31321 jj_consume_token(BINARY_INTEGER);
31322 break;
31323 case BODY:
31324 jj_consume_token(BODY);
31325 break;
31326 case BOOLEAN:
31327 jj_consume_token(BOOLEAN);
31328 break;
31329 case BY:
31330 jj_consume_token(BY);
31331 break;
31332 case CASE:
31333 jj_consume_token(CASE);
31334 break;
31335 case CHAR:
31336 jj_consume_token(CHAR);
31337 break;
31338 case CHAR_BASE:
31339 jj_consume_token(CHAR_BASE);
31340 break;
31341 case CHECK:
31342 jj_consume_token(CHECK);
31343 break;
31344 case CLUSTER:
31345 jj_consume_token(CLUSTER);
31346 break;
31347 case COMPRESS:
31348 jj_consume_token(COMPRESS);
31349 break;
31350 case CONNECT:
31351 jj_consume_token(CONNECT);
31352 break;
31353 case CONSTANT:
31354 jj_consume_token(CONSTANT);
31355 break;
31356 case CREATE:
31357 jj_consume_token(CREATE);
31358 break;
31359 case CURRVAL:
31360 jj_consume_token(CURRVAL);
31361 break;
31362 case DATE:
31363 jj_consume_token(DATE);
31364 break;
31365 case DECLARE:
31366 jj_consume_token(DECLARE);
31367 break;
31368 case DECIMAL:
31369 jj_consume_token(DECIMAL);
31370 break;
31371 case _DEFAULT:
31372 jj_consume_token(_DEFAULT);
31373 break;
31374 case DELETE:
31375 jj_consume_token(DELETE);
31376 break;
31377 case DESC:
31378 jj_consume_token(DESC);
31379 break;
31380 case DISTINCT:
31381 jj_consume_token(DISTINCT);
31382 break;
31383 case DO:
31384 jj_consume_token(DO);
31385 break;
31386 case DROP:
31387 jj_consume_token(DROP);
31388 break;
31389 case ELSE:
31390 jj_consume_token(ELSE);
31391 break;
31392 case ELSIF:
31393 jj_consume_token(ELSIF);
31394 break;
31395 case EXCEPTION:
31396 jj_consume_token(EXCEPTION);
31397 break;
31398 case EXCLUSIVE:
31399 jj_consume_token(EXCLUSIVE);
31400 break;
31401 case EXECUTE:
31402 jj_consume_token(EXECUTE);
31403 break;
31404 case EXISTS:
31405 jj_consume_token(EXISTS);
31406 break;
31407 case FETCH:
31408 jj_consume_token(FETCH);
31409 break;
31410 case FLOAT:
31411 jj_consume_token(FLOAT);
31412 break;
31413 case FOR:
31414 jj_consume_token(FOR);
31415 break;
31416 case FORALL:
31417 jj_consume_token(FORALL);
31418 break;
31419 case FROM:
31420 jj_consume_token(FROM);
31421 break;
31422 case GOTO:
31423 jj_consume_token(GOTO);
31424 break;
31425 case GROUP:
31426 jj_consume_token(GROUP);
31427 break;
31428 case HAVING:
31429 jj_consume_token(HAVING);
31430 break;
31431 case IF:
31432 jj_consume_token(IF);
31433 break;
31434 case IN:
31435 jj_consume_token(IN);
31436 break;
31437 case INDEX:
31438 jj_consume_token(INDEX);
31439 break;
31440 case INSERT:
31441 jj_consume_token(INSERT);
31442 break;
31443 case INTEGER:
31444 jj_consume_token(INTEGER);
31445 break;
31446 case INTERFACE:
31447 jj_consume_token(INTERFACE);
31448 break;
31449 case INTERSECT:
31450 jj_consume_token(INTERSECT);
31451 break;
31452 case INTO:
31453 jj_consume_token(INTO);
31454 break;
31455 case IS:
31456 jj_consume_token(IS);
31457 break;
31458 case LIKE:
31459 jj_consume_token(LIKE);
31460 break;
31461 case LIMITED:
31462 jj_consume_token(LIMITED);
31463 break;
31464 case LOCK:
31465 jj_consume_token(LOCK);
31466 break;
31467 case LONG:
31468 jj_consume_token(LONG);
31469 break;
31470 case LOOP:
31471 jj_consume_token(LOOP);
31472 break;
31473 case MINUS:
31474 jj_consume_token(MINUS);
31475 break;
31476 case MOD:
31477 jj_consume_token(MOD);
31478 break;
31479 case MODE:
31480 jj_consume_token(MODE);
31481 break;
31482 case NATURALN:
31483 jj_consume_token(NATURALN);
31484 break;
31485 case NEXTVAL:
31486 jj_consume_token(NEXTVAL);
31487 break;
31488 case NOCOPY:
31489 jj_consume_token(NOCOPY);
31490 break;
31491 case NOT:
31492 jj_consume_token(NOT);
31493 break;
31494 case NOWAIT:
31495 jj_consume_token(NOWAIT);
31496 break;
31497 case NULL:
31498 jj_consume_token(NULL);
31499 break;
31500 case NUMBER:
31501 jj_consume_token(NUMBER);
31502 break;
31503 case NUMBER_BASE:
31504 jj_consume_token(NUMBER_BASE);
31505 break;
31506 case OCIROWID:
31507 jj_consume_token(OCIROWID);
31508 break;
31509 case OF:
31510 jj_consume_token(OF);
31511 break;
31512 case ON:
31513 jj_consume_token(ON);
31514 break;
31515 case BFILE_BASE:
31516 jj_consume_token(BFILE_BASE);
31517 break;
31518 case BLOB_BASE:
31519 jj_consume_token(BLOB_BASE);
31520 break;
31521 case CLOB_BASE:
31522 jj_consume_token(CLOB_BASE);
31523 break;
31524 case DATE_BASE:
31525 jj_consume_token(DATE_BASE);
31526 break;
31527 case OPERATOR:
31528 jj_consume_token(OPERATOR);
31529 break;
31530 case OPTION:
31531 jj_consume_token(OPTION);
31532 break;
31533 case OR:
31534 jj_consume_token(OR);
31535 break;
31536 case ORDER:
31537 jj_consume_token(ORDER);
31538 break;
31539 case OUT:
31540 jj_consume_token(OUT);
31541 break;
31542 case PCTFREE:
31543 jj_consume_token(PCTFREE);
31544 break;
31545 case PLS_INTEGER:
31546 jj_consume_token(PLS_INTEGER);
31547 break;
31548 case POSITIVE:
31549 jj_consume_token(POSITIVE);
31550 break;
31551 case POSITIVEN:
31552 jj_consume_token(POSITIVEN);
31553 break;
31554 case PRIOR:
31555 jj_consume_token(PRIOR);
31556 break;
31557 case PRIVATE:
31558 jj_consume_token(PRIVATE);
31559 break;
31560 case PROMPT:
31561 jj_consume_token(PROMPT);
31562 break;
31563 case PUBLIC:
31564 jj_consume_token(PUBLIC);
31565 break;
31566 case RAISE:
31567 jj_consume_token(RAISE);
31568 break;
31569 case RAW:
31570 jj_consume_token(RAW);
31571 break;
31572 case ROWTYPE:
31573 jj_consume_token(ROWTYPE);
31574 break;
31575 case SELECT:
31576 jj_consume_token(SELECT);
31577 break;
31578 case SEPARATE:
31579 jj_consume_token(SEPARATE);
31580 break;
31581 case SHARE:
31582 jj_consume_token(SHARE);
31583 break;
31584 case SMALLINT:
31585 jj_consume_token(SMALLINT);
31586 break;
31587 case SQL:
31588 jj_consume_token(SQL);
31589 break;
31590 case SQLCODE:
31591 jj_consume_token(SQLCODE);
31592 break;
31593 case SQLERRM:
31594 jj_consume_token(SQLERRM);
31595 break;
31596 case START:
31597 jj_consume_token(START);
31598 break;
31599 case STDDEV:
31600 jj_consume_token(STDDEV);
31601 break;
31602 case SUM:
31603 jj_consume_token(SUM);
31604 break;
31605 case SYNONYM:
31606 jj_consume_token(SYNONYM);
31607 break;
31608 case SYSDATE:
31609 jj_consume_token(SYSDATE);
31610 break;
31611 case TABLE:
31612 jj_consume_token(TABLE);
31613 break;
31614 case THEN:
31615 jj_consume_token(THEN);
31616 break;
31617 case TO:
31618 jj_consume_token(TO);
31619 break;
31620 case TRIGGER:
31621 jj_consume_token(TRIGGER);
31622 break;
31623 case TYPE:
31624 jj_consume_token(TYPE);
31625 break;
31626 case UI:
31627 jj_consume_token(UI);
31628 break;
31629 case UPDATE:
31630 jj_consume_token(UPDATE);
31631 break;
31632 case VARCHAR:
31633 jj_consume_token(VARCHAR);
31634 break;
31635 case VARCHAR2:
31636 jj_consume_token(VARCHAR2);
31637 break;
31638 case INT:
31639 jj_consume_token(INT);
31640 break;
31641 case SIGNTYPE:
31642 jj_consume_token(SIGNTYPE);
31643 break;
31644 case STRING:
31645 jj_consume_token(STRING);
31646 break;
31647 case WITH:
31648 jj_consume_token(WITH);
31649 break;
31650 case WHILE:
31651 jj_consume_token(WHILE);
31652 break;
31653 case JAVA_INTERFACE_CLASS:
31654 jj_consume_token(JAVA_INTERFACE_CLASS);
31655 break;
31656 case SQLDATA_CLASS:
31657 jj_consume_token(SQLDATA_CLASS);
31658 break;
31659 case CUSTOMDATUM_CLASS:
31660 jj_consume_token(CUSTOMDATUM_CLASS);
31661 break;
31662 case ORADATA_CLASS:
31663 jj_consume_token(ORADATA_CLASS);
31664 break;
31665 default:
31666 jj_la1[455] = jj_gen;
31667 jj_consume_token(-1);
31668 throw new ParseException();
31669 }
31670 jjtree.closeNodeScope(jjtn000, true);
31671 jjtc000 = false;
31672 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31673 } catch (Throwable jjte000) {
31674 if (jjtc000) {
31675 jjtree.clearNodeScope(jjtn000);
31676 jjtc000 = false;
31677 } else {
31678 jjtree.popNode();
31679 }
31680 if (jjte000 instanceof RuntimeException) {
31681 {if (true) throw (RuntimeException)jjte000;}
31682 }
31683 if (jjte000 instanceof ParseException) {
31684 {if (true) throw (ParseException)jjte000;}
31685 }
31686 {if (true) throw (Error)jjte000;}
31687 } finally {
31688 if (jjtc000) {
31689 jjtree.closeNodeScope(jjtn000, true);
31690 }
31691 }
31692 throw new Error("Missing return statement in function");
31693 }
31694
31695
31696
31697
31698 final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31699
31700 ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31701 boolean jjtc000 = true;
31702 jjtree.openNodeScope(jjtn000);
31703 try {
31704 switch (jj_nt.kind) {
31705 case IDENTIFIER:
31706 jj_consume_token(IDENTIFIER);
31707 break;
31708 case QUOTED_LITERAL:
31709 jj_consume_token(QUOTED_LITERAL);
31710 break;
31711 case DEFINER:
31712 case CURRENT_USER:
31713 case LANGUAGE:
31714 case INLINE:
31715 case ADD:
31716 case AGGREGATE:
31717 case AT:
31718 case ATTRIBUTE:
31719 case AUTHID:
31720 case BULK:
31721 case BYTE:
31722 case CASCADE:
31723 case CLOSE:
31724 case COALESCE:
31725 case COLLECT:
31726 case COLUMN:
31727 case COMMENT:
31728 case COMMIT:
31729 case CONSTRUCTOR:
31730 case CONTINUE:
31731 case CONVERT:
31732 case CURRENT:
31733 case CURSOR:
31734 case DATA:
31735 case DAY:
31736 case DISABLE:
31737 case EDITIONABLE:
31738 case ELEMENT:
31739 case ENABLE:
31740 case ESCAPE:
31741 case EXCEPT:
31742 case EXCEPTIONS:
31743 case EXIT:
31744 case EXTERNAL:
31745 case EXTENDS:
31746 case EXTRACT:
31747 case FALSE:
31748 case FINAL:
31749 case FORCE:
31750 case FUNCTION:
31751 case GLOBAL:
31752 case HASH:
31753 case HEAP:
31754 case HOUR:
31755 case IMMEDIATE:
31756 case INDICES:
31757 case INDEXTYPE:
31758 case INDICATOR:
31759 case INSTANTIABLE:
31760 case INTERVAL:
31761 case INVALIDATE:
31762 case ISOLATION:
31763 case JAVA:
31764 case LEVEL:
31765 case LIMIT:
31766 case MAP:
31767 case MAX:
31768 case MEMBER:
31769 case MERGE:
31770 case MIN:
31771 case MINUTE:
31772 case MLSLABEL:
31773 case MODIFY:
31774 case MONTH:
31775 case NATURAL:
31776 case NEW:
31777 case NO:
31778 case NONEDITIONABLE:
31779 case NULLIF:
31780 case OBJECT:
31781 case OID:
31782 case OPAQUE:
31783 case OPEN:
31784 case ORGANIZATION:
31785 case OTHERS:
31786 case OVERRIDING:
31787 case PACKAGE:
31788 case PARTITION:
31789 case PRESERVE:
31790 case PROCEDURE:
31791 case RANGE:
31792 case REAL:
31793 case RECORD:
31794 case REF:
31795 case RELEASE:
31796 case RELIES_ON:
31797 case RENAME:
31798 case RESULT:
31799 case RETURN:
31800 case RETURNING:
31801 case REVERSE:
31802 case ROLLBACK:
31803 case ROW:
31804 case ROWS:
31805 case ROWID:
31806 case ROWNUM:
31807 case SAVE:
31808 case SAVEPOINT:
31809 case SECOND:
31810 case SELF:
31811 case SET:
31812 case SPACE:
31813 case STATIC:
31814 case SUBTYPE:
31815 case SUBSTITUTABLE:
31816 case SUCCESSFUL:
31817 case SYS_REFCURSOR:
31818 case TEMPORARY:
31819 case TIME:
31820 case TIMESTAMP:
31821 case TIMEZONE_REGION:
31822 case TIMEZONE_ABBR:
31823 case TIMEZONE_MINUTE:
31824 case TIMEZONE_HOUR:
31825 case TRANSACTION:
31826 case TRUE:
31827 case UNDER:
31828 case USING:
31829 case YES:
31830 case SHOW:
31831 case A:
31832 case DOUBLE:
31833 case DEC:
31834 case PRECISION:
31835 case NUMERIC:
31836 case NCHAR:
31837 case NVARCHAR2:
31838 case UROWID:
31839 case VARRAY:
31840 case VARYING:
31841 case BFILE:
31842 case BLOB:
31843 case CLOB:
31844 case NCLOB:
31845 case YEAR:
31846 case LOCAL:
31847 case ZONE:
31848 case CHARACTER:
31849 case AFTER:
31850 case BEFORE:
31851 case OLD:
31852 case PARENT:
31853 case ANALYZE:
31854 case ASSOCIATE:
31855 case AUDIT:
31856 case COMPOUND:
31857 case DATABASE:
31858 case CALL:
31859 case DDL:
31860 case DISASSOCIATE:
31861 case EACH:
31862 case FOLLOWS:
31863 case LOGOFF:
31864 case LOGON:
31865 case NESTED:
31866 case NOAUDIT:
31867 case SCHEMA:
31868 case SERVERERROR:
31869 case SHUTDOWN:
31870 case STARTUP:
31871 case STATEMENT:
31872 case STATISTICS:
31873 case SUSPEND:
31874 case TRUNCATE:
31875 case WRAPPED:
31876 case LIBRARY:
31877 case NAME:
31878 case STRUCT:
31879 case CONTEXT:
31880 case PARAMETERS:
31881 case LENGTH:
31882 case TDO:
31883 case MAXLEN:
31884 case CHARSETID:
31885 case CHARSETFORM:
31886 case ACCEPT:
31887 case ACCESSIBLE:
31888 case COPY:
31889 case DEFINE:
31890 case DISCONNECT:
31891 case HOST:
31892 case PRINT:
31893 case QUIT:
31894 case REMARK:
31895 case UNDEFINE:
31896 case VARIABLE:
31897 case WHENEVER:
31898 case ATTACH:
31899 case CAST:
31900 case TREAT:
31901 case TRIM:
31902 case LEFT:
31903 case RIGHT:
31904 case BOTH:
31905 case EMPTY:
31906 case MULTISET:
31907 case SUBMULTISET:
31908 case LEADING:
31909 case TRAILING:
31910 case CHAR_CS:
31911 case NCHAR_CS:
31912 case DBTIMEZONE:
31913 case SESSIONTIMEZONE:
31914 case AUTHENTICATED:
31915 case LINK:
31916 case SHARED:
31917 case DIRECTORY:
31918 case USER:
31919 KEYWORD_UNRESERVED();
31920 break;
31921 case BODY:
31922 jj_consume_token(BODY);
31923 break;
31924 case MOD:
31925 jj_consume_token(MOD);
31926 break;
31927 case OPERATOR:
31928 jj_consume_token(OPERATOR);
31929 break;
31930 case PRIVATE:
31931 jj_consume_token(PRIVATE);
31932 break;
31933 case RAW:
31934 jj_consume_token(RAW);
31935 break;
31936 case REPLACE:
31937 jj_consume_token(REPLACE);
31938 break;
31939 case STRING:
31940 jj_consume_token(STRING);
31941 break;
31942 case SQL:
31943 jj_consume_token(SQL);
31944 break;
31945 case SQLCODE:
31946 jj_consume_token(SQLCODE);
31947 break;
31948 case SQLERRM:
31949 jj_consume_token(SQLERRM);
31950 break;
31951 case SYSDATE:
31952 jj_consume_token(SYSDATE);
31953 break;
31954 case TYPE:
31955 jj_consume_token(TYPE);
31956 break;
31957 case LOOP:
31958 jj_consume_token(LOOP);
31959 break;
31960 case INT:
31961 jj_consume_token(INT);
31962 break;
31963 case ARRAY:
31964 jj_consume_token(ARRAY);
31965 break;
31966 default:
31967 jj_la1[456] = jj_gen;
31968 jj_consume_token(-1);
31969 throw new ParseException();
31970 }
31971 jjtree.closeNodeScope(jjtn000, true);
31972 jjtc000 = false;
31973 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31974 } catch (Throwable jjte000) {
31975 if (jjtc000) {
31976 jjtree.clearNodeScope(jjtn000);
31977 jjtc000 = false;
31978 } else {
31979 jjtree.popNode();
31980 }
31981 if (jjte000 instanceof RuntimeException) {
31982 {if (true) throw (RuntimeException)jjte000;}
31983 }
31984 if (jjte000 instanceof ParseException) {
31985 {if (true) throw (ParseException)jjte000;}
31986 }
31987 {if (true) throw (Error)jjte000;}
31988 } finally {
31989 if (jjtc000) {
31990 jjtree.closeNodeScope(jjtn000, true);
31991 }
31992 }
31993 throw new Error("Missing return statement in function");
31994 }
31995
31996
31997
31998
31999 final public ASTQualifiedID QualifiedID() throws ParseException {
32000
32001 ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
32002 boolean jjtc000 = true;
32003 jjtree.openNodeScope(jjtn000);
32004 try {
32005 switch (jj_nt.kind) {
32006 case IDENTIFIER:
32007 jj_consume_token(IDENTIFIER);
32008 break;
32009 case QUOTED_LITERAL:
32010 jj_consume_token(QUOTED_LITERAL);
32011 break;
32012 case DEFINER:
32013 case CURRENT_USER:
32014 case LANGUAGE:
32015 case INLINE:
32016 case ADD:
32017 case AGGREGATE:
32018 case AT:
32019 case ATTRIBUTE:
32020 case AUTHID:
32021 case BULK:
32022 case BYTE:
32023 case CASCADE:
32024 case CLOSE:
32025 case COALESCE:
32026 case COLLECT:
32027 case COLUMN:
32028 case COMMENT:
32029 case COMMIT:
32030 case CONSTRUCTOR:
32031 case CONTINUE:
32032 case CONVERT:
32033 case CURRENT:
32034 case CURSOR:
32035 case DATA:
32036 case DAY:
32037 case DISABLE:
32038 case EDITIONABLE:
32039 case ELEMENT:
32040 case ENABLE:
32041 case ESCAPE:
32042 case EXCEPT:
32043 case EXCEPTIONS:
32044 case EXIT:
32045 case EXTERNAL:
32046 case EXTENDS:
32047 case EXTRACT:
32048 case FALSE:
32049 case FINAL:
32050 case FORCE:
32051 case FUNCTION:
32052 case GLOBAL:
32053 case HASH:
32054 case HEAP:
32055 case HOUR:
32056 case IMMEDIATE:
32057 case INDICES:
32058 case INDEXTYPE:
32059 case INDICATOR:
32060 case INSTANTIABLE:
32061 case INTERVAL:
32062 case INVALIDATE:
32063 case ISOLATION:
32064 case JAVA:
32065 case LEVEL:
32066 case LIMIT:
32067 case MAP:
32068 case MAX:
32069 case MEMBER:
32070 case MERGE:
32071 case MIN:
32072 case MINUTE:
32073 case MLSLABEL:
32074 case MODIFY:
32075 case MONTH:
32076 case NATURAL:
32077 case NEW:
32078 case NO:
32079 case NONEDITIONABLE:
32080 case NULLIF:
32081 case OBJECT:
32082 case OID:
32083 case OPAQUE:
32084 case OPEN:
32085 case ORGANIZATION:
32086 case OTHERS:
32087 case OVERRIDING:
32088 case PACKAGE:
32089 case PARTITION:
32090 case PRESERVE:
32091 case PROCEDURE:
32092 case RANGE:
32093 case REAL:
32094 case RECORD:
32095 case REF:
32096 case RELEASE:
32097 case RELIES_ON:
32098 case RENAME:
32099 case RESULT:
32100 case RETURN:
32101 case RETURNING:
32102 case REVERSE:
32103 case ROLLBACK:
32104 case ROW:
32105 case ROWS:
32106 case ROWID:
32107 case ROWNUM:
32108 case SAVE:
32109 case SAVEPOINT:
32110 case SECOND:
32111 case SELF:
32112 case SET:
32113 case SPACE:
32114 case STATIC:
32115 case SUBTYPE:
32116 case SUBSTITUTABLE:
32117 case SUCCESSFUL:
32118 case SYS_REFCURSOR:
32119 case TEMPORARY:
32120 case TIME:
32121 case TIMESTAMP:
32122 case TIMEZONE_REGION:
32123 case TIMEZONE_ABBR:
32124 case TIMEZONE_MINUTE:
32125 case TIMEZONE_HOUR:
32126 case TRANSACTION:
32127 case TRUE:
32128 case UNDER:
32129 case USING:
32130 case YES:
32131 case SHOW:
32132 case A:
32133 case DOUBLE:
32134 case DEC:
32135 case PRECISION:
32136 case NUMERIC:
32137 case NCHAR:
32138 case NVARCHAR2:
32139 case UROWID:
32140 case VARRAY:
32141 case VARYING:
32142 case BFILE:
32143 case BLOB:
32144 case CLOB:
32145 case NCLOB:
32146 case YEAR:
32147 case LOCAL:
32148 case ZONE:
32149 case CHARACTER:
32150 case AFTER:
32151 case BEFORE:
32152 case OLD:
32153 case PARENT:
32154 case ANALYZE:
32155 case ASSOCIATE:
32156 case AUDIT:
32157 case COMPOUND:
32158 case DATABASE:
32159 case CALL:
32160 case DDL:
32161 case DISASSOCIATE:
32162 case EACH:
32163 case FOLLOWS:
32164 case LOGOFF:
32165 case LOGON:
32166 case NESTED:
32167 case NOAUDIT:
32168 case SCHEMA:
32169 case SERVERERROR:
32170 case SHUTDOWN:
32171 case STARTUP:
32172 case STATEMENT:
32173 case STATISTICS:
32174 case SUSPEND:
32175 case TRUNCATE:
32176 case WRAPPED:
32177 case LIBRARY:
32178 case NAME:
32179 case STRUCT:
32180 case CONTEXT:
32181 case PARAMETERS:
32182 case LENGTH:
32183 case TDO:
32184 case MAXLEN:
32185 case CHARSETID:
32186 case CHARSETFORM:
32187 case ACCEPT:
32188 case ACCESSIBLE:
32189 case COPY:
32190 case DEFINE:
32191 case DISCONNECT:
32192 case HOST:
32193 case PRINT:
32194 case QUIT:
32195 case REMARK:
32196 case UNDEFINE:
32197 case VARIABLE:
32198 case WHENEVER:
32199 case ATTACH:
32200 case CAST:
32201 case TREAT:
32202 case TRIM:
32203 case LEFT:
32204 case RIGHT:
32205 case BOTH:
32206 case EMPTY:
32207 case MULTISET:
32208 case SUBMULTISET:
32209 case LEADING:
32210 case TRAILING:
32211 case CHAR_CS:
32212 case NCHAR_CS:
32213 case DBTIMEZONE:
32214 case SESSIONTIMEZONE:
32215 case AUTHENTICATED:
32216 case LINK:
32217 case SHARED:
32218 case DIRECTORY:
32219 case USER:
32220 KEYWORD_UNRESERVED();
32221 break;
32222 case REPLACE:
32223 jj_consume_token(REPLACE);
32224 break;
32225 case SERIALLY_REUSABLE:
32226 jj_consume_token(SERIALLY_REUSABLE);
32227 break;
32228 case RESTRICT_REFERENCES:
32229 jj_consume_token(RESTRICT_REFERENCES);
32230 break;
32231 case EXCEPTION_INIT:
32232 jj_consume_token(EXCEPTION_INIT);
32233 break;
32234 case AUTONOMOUS_TRANSACTION:
32235 jj_consume_token(AUTONOMOUS_TRANSACTION);
32236 break;
32237 case ARRAY:
32238 jj_consume_token(ARRAY);
32239 break;
32240 case AVG:
32241 jj_consume_token(AVG);
32242 break;
32243 case BINARY_INTEGER:
32244 jj_consume_token(BINARY_INTEGER);
32245 break;
32246 case BODY:
32247 jj_consume_token(BODY);
32248 break;
32249 case BOOLEAN:
32250 jj_consume_token(BOOLEAN);
32251 break;
32252 case CHAR:
32253 jj_consume_token(CHAR);
32254 break;
32255 case CHAR_BASE:
32256 jj_consume_token(CHAR_BASE);
32257 break;
32258 case CONSTANT:
32259 jj_consume_token(CONSTANT);
32260 break;
32261 case CURRVAL:
32262 jj_consume_token(CURRVAL);
32263 break;
32264 case DATE:
32265 jj_consume_token(DATE);
32266 break;
32267 case DECIMAL:
32268 jj_consume_token(DECIMAL);
32269 break;
32270 case DELETE:
32271 jj_consume_token(DELETE);
32272 break;
32273 case DO:
32274 jj_consume_token(DO);
32275 break;
32276 case ELSIF:
32277 jj_consume_token(ELSIF);
32278 break;
32279 case EXECUTE:
32280 jj_consume_token(EXECUTE);
32281 break;
32282 case EXISTS:
32283 jj_consume_token(EXISTS);
32284 break;
32285 case FLOAT:
32286 jj_consume_token(FLOAT);
32287 break;
32288 case FORALL:
32289 jj_consume_token(FORALL);
32290 break;
32291 case INTEGER:
32292 jj_consume_token(INTEGER);
32293 break;
32294 case INTERFACE:
32295 jj_consume_token(INTERFACE);
32296 break;
32297 case LONG:
32298 jj_consume_token(LONG);
32299 break;
32300 case LOOP:
32301 jj_consume_token(LOOP);
32302 break;
32303 case MOD:
32304 jj_consume_token(MOD);
32305 break;
32306 case NATURALN:
32307 jj_consume_token(NATURALN);
32308 break;
32309 case NEXTVAL:
32310 jj_consume_token(NEXTVAL);
32311 break;
32312 case NOCOPY:
32313 jj_consume_token(NOCOPY);
32314 break;
32315 case NUMBER:
32316 jj_consume_token(NUMBER);
32317 break;
32318 case BFILE_BASE:
32319 jj_consume_token(BFILE_BASE);
32320 break;
32321 case BLOB_BASE:
32322 jj_consume_token(BLOB_BASE);
32323 break;
32324 case CLOB_BASE:
32325 jj_consume_token(CLOB_BASE);
32326 break;
32327 case DATE_BASE:
32328 jj_consume_token(DATE_BASE);
32329 break;
32330 case NUMBER_BASE:
32331 jj_consume_token(NUMBER_BASE);
32332 break;
32333 case OCIROWID:
32334 jj_consume_token(OCIROWID);
32335 break;
32336 case OPERATOR:
32337 jj_consume_token(OPERATOR);
32338 break;
32339 case OUT:
32340 jj_consume_token(OUT);
32341 break;
32342 case PLS_INTEGER:
32343 jj_consume_token(PLS_INTEGER);
32344 break;
32345 case POSITIVE:
32346 jj_consume_token(POSITIVE);
32347 break;
32348 case POSITIVEN:
32349 jj_consume_token(POSITIVEN);
32350 break;
32351 case PRAGMA:
32352 jj_consume_token(PRAGMA);
32353 break;
32354 case PRIOR:
32355 jj_consume_token(PRIOR);
32356 break;
32357 case PRIVATE:
32358 jj_consume_token(PRIVATE);
32359 break;
32360 case PROMPT:
32361 jj_consume_token(PROMPT);
32362 break;
32363 case RAISE:
32364 jj_consume_token(RAISE);
32365 break;
32366 case RAW:
32367 jj_consume_token(RAW);
32368 break;
32369 case ROWTYPE:
32370 jj_consume_token(ROWTYPE);
32371 break;
32372 case SEPARATE:
32373 jj_consume_token(SEPARATE);
32374 break;
32375 case SMALLINT:
32376 jj_consume_token(SMALLINT);
32377 break;
32378 case SQLCODE:
32379 jj_consume_token(SQLCODE);
32380 break;
32381 case SQLERRM:
32382 jj_consume_token(SQLERRM);
32383 break;
32384 case STDDEV:
32385 jj_consume_token(STDDEV);
32386 break;
32387 case SUM:
32388 jj_consume_token(SUM);
32389 break;
32390 case SYNONYM:
32391 jj_consume_token(SYNONYM);
32392 break;
32393 case SYSDATE:
32394 jj_consume_token(SYSDATE);
32395 break;
32396 case TRIGGER:
32397 jj_consume_token(TRIGGER);
32398 break;
32399 case TYPE:
32400 jj_consume_token(TYPE);
32401 break;
32402 case UI:
32403 jj_consume_token(UI);
32404 break;
32405 case VARCHAR:
32406 jj_consume_token(VARCHAR);
32407 break;
32408 case VARCHAR2:
32409 jj_consume_token(VARCHAR2);
32410 break;
32411 case INT:
32412 jj_consume_token(INT);
32413 break;
32414 case SIGNTYPE:
32415 jj_consume_token(SIGNTYPE);
32416 break;
32417 case STRING:
32418 jj_consume_token(STRING);
32419 break;
32420 case WHILE:
32421 jj_consume_token(WHILE);
32422 break;
32423 default:
32424 jj_la1[457] = jj_gen;
32425 jj_consume_token(-1);
32426 throw new ParseException();
32427 }
32428 jjtree.closeNodeScope(jjtn000, true);
32429 jjtc000 = false;
32430 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32431 } catch (Throwable jjte000) {
32432 if (jjtc000) {
32433 jjtree.clearNodeScope(jjtn000);
32434 jjtc000 = false;
32435 } else {
32436 jjtree.popNode();
32437 }
32438 if (jjte000 instanceof RuntimeException) {
32439 {if (true) throw (RuntimeException)jjte000;}
32440 }
32441 if (jjte000 instanceof ParseException) {
32442 {if (true) throw (ParseException)jjte000;}
32443 }
32444 {if (true) throw (Error)jjte000;}
32445 } finally {
32446 if (jjtc000) {
32447 jjtree.closeNodeScope(jjtn000, true);
32448 }
32449 }
32450 throw new Error("Missing return statement in function");
32451 }
32452
32453 final public ASTTypeKeyword TypeKeyword() throws ParseException {
32454
32455 ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
32456 boolean jjtc000 = true;
32457 jjtree.openNodeScope(jjtn000);
32458 try {
32459 switch (jj_nt.kind) {
32460 case BFILE_BASE:
32461 jj_consume_token(BFILE_BASE);
32462 break;
32463 case BLOB_BASE:
32464 jj_consume_token(BLOB_BASE);
32465 break;
32466 case CLOB_BASE:
32467 jj_consume_token(CLOB_BASE);
32468 break;
32469 case DATE_BASE:
32470 jj_consume_token(DATE_BASE);
32471 break;
32472 case NUMBER_BASE:
32473 jj_consume_token(NUMBER_BASE);
32474 break;
32475 case BOOLEAN:
32476 jj_consume_token(BOOLEAN);
32477 break;
32478 case DATE:
32479 jj_consume_token(DATE);
32480 break;
32481 case NUMBER:
32482 jj_consume_token(NUMBER);
32483 break;
32484 case FLOAT:
32485 jj_consume_token(FLOAT);
32486 break;
32487 case REAL:
32488 jj_consume_token(REAL);
32489 break;
32490 case INTEGER:
32491 jj_consume_token(INTEGER);
32492 break;
32493 case INT:
32494 jj_consume_token(INT);
32495 break;
32496 case SMALLINT:
32497 jj_consume_token(SMALLINT);
32498 break;
32499 case DECIMAL:
32500 jj_consume_token(DECIMAL);
32501 break;
32502 case NUMERIC:
32503 jj_consume_token(NUMERIC);
32504 break;
32505 case DEC:
32506 jj_consume_token(DEC);
32507 break;
32508 case BINARY_INTEGER:
32509 jj_consume_token(BINARY_INTEGER);
32510 break;
32511 case NATURAL:
32512 jj_consume_token(NATURAL);
32513 break;
32514 case NATURALN:
32515 jj_consume_token(NATURALN);
32516 break;
32517 case POSITIVE:
32518 jj_consume_token(POSITIVE);
32519 break;
32520 case POSITIVEN:
32521 jj_consume_token(POSITIVEN);
32522 break;
32523 case SIGNTYPE:
32524 jj_consume_token(SIGNTYPE);
32525 break;
32526 case VARCHAR2:
32527 jj_consume_token(VARCHAR2);
32528 break;
32529 case VARCHAR:
32530 jj_consume_token(VARCHAR);
32531 break;
32532 case STRING:
32533 jj_consume_token(STRING);
32534 break;
32535 case LONG:
32536 jj_consume_token(LONG);
32537 break;
32538 case RAW:
32539 jj_consume_token(RAW);
32540 break;
32541 case ROWID:
32542 jj_consume_token(ROWID);
32543 break;
32544 case CHAR:
32545 jj_consume_token(CHAR);
32546 break;
32547 case CHARACTER:
32548 jj_consume_token(CHARACTER);
32549 break;
32550 case MLSLABEL:
32551 jj_consume_token(MLSLABEL);
32552 break;
32553 case BLOB:
32554 jj_consume_token(BLOB);
32555 break;
32556 case CLOB:
32557 jj_consume_token(CLOB);
32558 break;
32559 case BFILE:
32560 jj_consume_token(BFILE);
32561 break;
32562 case NCHAR:
32563 jj_consume_token(NCHAR);
32564 break;
32565 case NVARCHAR2:
32566 jj_consume_token(NVARCHAR2);
32567 break;
32568 case NCLOB:
32569 jj_consume_token(NCLOB);
32570 break;
32571 case PLS_INTEGER:
32572 jj_consume_token(PLS_INTEGER);
32573 break;
32574 case TIME:
32575 jj_consume_token(TIME);
32576 break;
32577 case TIMESTAMP:
32578 jj_consume_token(TIMESTAMP);
32579 break;
32580 case UROWID:
32581 jj_consume_token(UROWID);
32582 break;
32583 case ARRAY:
32584 jj_consume_token(ARRAY);
32585 break;
32586 case AUTHID:
32587 jj_consume_token(AUTHID);
32588 break;
32589 case ACCESSIBLE:
32590 jj_consume_token(ACCESSIBLE);
32591 jj_consume_token(CHAR_BASE);
32592 break;
32593 case CURRVAL:
32594 jj_consume_token(CURRVAL);
32595 break;
32596 case HOUR:
32597 jj_consume_token(HOUR);
32598 break;
32599 case INTERVAL:
32600 jj_consume_token(INTERVAL);
32601 break;
32602 case MONTH:
32603 jj_consume_token(MONTH);
32604 break;
32605 case OCIROWID:
32606 jj_consume_token(OCIROWID);
32607 break;
32608 case RECORD:
32609 jj_consume_token(RECORD);
32610 break;
32611 case REF:
32612 jj_consume_token(REF);
32613 break;
32614 case ROW:
32615 jj_consume_token(ROW);
32616 break;
32617 case ROWNUM:
32618 jj_consume_token(ROWNUM);
32619 break;
32620 case ROWTYPE:
32621 jj_consume_token(ROWTYPE);
32622 break;
32623 case SECOND:
32624 jj_consume_token(SECOND);
32625 break;
32626 case SET:
32627 jj_consume_token(SET);
32628 break;
32629 case TABLE:
32630 jj_consume_token(TABLE);
32631 break;
32632 case TIMEZONE_REGION:
32633 jj_consume_token(TIMEZONE_REGION);
32634 break;
32635 case TIMEZONE_ABBR:
32636 jj_consume_token(TIMEZONE_ABBR);
32637 break;
32638 case TIMEZONE_MINUTE:
32639 jj_consume_token(TIMEZONE_MINUTE);
32640 break;
32641 case TIMEZONE_HOUR:
32642 jj_consume_token(TIMEZONE_HOUR);
32643 break;
32644 case DOUBLE:
32645 jj_consume_token(DOUBLE);
32646 break;
32647 case PRECISION:
32648 jj_consume_token(PRECISION);
32649 break;
32650 case VARRAY:
32651 jj_consume_token(VARRAY);
32652 break;
32653 case YEAR:
32654 jj_consume_token(YEAR);
32655 break;
32656 case LOCAL:
32657 jj_consume_token(LOCAL);
32658 break;
32659 case WITH:
32660 jj_consume_token(WITH);
32661 break;
32662 case ZONE:
32663 jj_consume_token(ZONE);
32664 break;
32665 case JAVA_INTERFACE_CLASS:
32666 jj_consume_token(JAVA_INTERFACE_CLASS);
32667 break;
32668 case SQLDATA_CLASS:
32669 jj_consume_token(SQLDATA_CLASS);
32670 break;
32671 case CUSTOMDATUM_CLASS:
32672 jj_consume_token(CUSTOMDATUM_CLASS);
32673 break;
32674 case ORADATA_CLASS:
32675 jj_consume_token(ORADATA_CLASS);
32676 break;
32677 default:
32678 jj_la1[458] = jj_gen;
32679 jj_consume_token(-1);
32680 throw new ParseException();
32681 }
32682 jjtree.closeNodeScope(jjtn000, true);
32683 jjtc000 = false;
32684 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32685 } finally {
32686 if (jjtc000) {
32687 jjtree.closeNodeScope(jjtn000, true);
32688 }
32689 }
32690 throw new Error("Missing return statement in function");
32691 }
32692
32693 final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32694
32695 ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32696 boolean jjtc000 = true;
32697 jjtree.openNodeScope(jjtn000);
32698 try {
32699 switch (jj_nt.kind) {
32700 case SQLDATA_CLASS:
32701 jj_consume_token(SQLDATA_CLASS);
32702 break;
32703 case CUSTOMDATUM_CLASS:
32704 jj_consume_token(CUSTOMDATUM_CLASS);
32705 break;
32706 case ORADATA_CLASS:
32707 jj_consume_token(ORADATA_CLASS);
32708 break;
32709 default:
32710 jj_la1[459] = jj_gen;
32711 jj_consume_token(-1);
32712 throw new ParseException();
32713 }
32714 jjtree.closeNodeScope(jjtn000, true);
32715 jjtc000 = false;
32716 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32717 } finally {
32718 if (jjtc000) {
32719 jjtree.closeNodeScope(jjtn000, true);
32720 }
32721 }
32722 throw new Error("Missing return statement in function");
32723 }
32724
32725
32726
32727
32728
32729
32730
32731 final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32732
32733 ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32734 boolean jjtc000 = true;
32735 jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32736 Token oldIDToken;
32737 Token newIDToken;
32738 try {
32739 newID = ID();
32740 jjtree.closeNodeScope(jjtn000, true);
32741 jjtc000 = false;
32742 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32743 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32744 if (oldIDToken.image.equals(newIDToken.image)) {
32745 {if (true) return newID;}
32746 } else {
32747 {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32748 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32749 }
32750 } catch (Throwable jjte000) {
32751 if (jjtc000) {
32752 jjtree.clearNodeScope(jjtn000);
32753 jjtc000 = false;
32754 } else {
32755 jjtree.popNode();
32756 }
32757 if (jjte000 instanceof RuntimeException) {
32758 {if (true) throw (RuntimeException)jjte000;}
32759 }
32760 if (jjte000 instanceof ParseException) {
32761 {if (true) throw (ParseException)jjte000;}
32762 }
32763 {if (true) throw (Error)jjte000;}
32764 } finally {
32765 if (jjtc000) {
32766 jjtree.closeNodeScope(jjtn000, true);
32767 }
32768 }
32769 throw new Error("Missing return statement in function");
32770 }
32771
32772 private boolean jj_2_1(int xla) {
32773 jj_la = xla; jj_lastpos = jj_scanpos = token;
32774 try { return !jj_3_1(); }
32775 catch(LookaheadSuccess ls) { return true; }
32776 finally { jj_save(0, xla); }
32777 }
32778
32779 private boolean jj_2_2(int xla) {
32780 jj_la = xla; jj_lastpos = jj_scanpos = token;
32781 try { return !jj_3_2(); }
32782 catch(LookaheadSuccess ls) { return true; }
32783 finally { jj_save(1, xla); }
32784 }
32785
32786 private boolean jj_2_3(int xla) {
32787 jj_la = xla; jj_lastpos = jj_scanpos = token;
32788 try { return !jj_3_3(); }
32789 catch(LookaheadSuccess ls) { return true; }
32790 finally { jj_save(2, xla); }
32791 }
32792
32793 private boolean jj_2_4(int xla) {
32794 jj_la = xla; jj_lastpos = jj_scanpos = token;
32795 try { return !jj_3_4(); }
32796 catch(LookaheadSuccess ls) { return true; }
32797 finally { jj_save(3, xla); }
32798 }
32799
32800 private boolean jj_2_5(int xla) {
32801 jj_la = xla; jj_lastpos = jj_scanpos = token;
32802 try { return !jj_3_5(); }
32803 catch(LookaheadSuccess ls) { return true; }
32804 finally { jj_save(4, xla); }
32805 }
32806
32807 private boolean jj_2_6(int xla) {
32808 jj_la = xla; jj_lastpos = jj_scanpos = token;
32809 try { return !jj_3_6(); }
32810 catch(LookaheadSuccess ls) { return true; }
32811 finally { jj_save(5, xla); }
32812 }
32813
32814 private boolean jj_2_7(int xla) {
32815 jj_la = xla; jj_lastpos = jj_scanpos = token;
32816 try { return !jj_3_7(); }
32817 catch(LookaheadSuccess ls) { return true; }
32818 finally { jj_save(6, xla); }
32819 }
32820
32821 private boolean jj_2_8(int xla) {
32822 jj_la = xla; jj_lastpos = jj_scanpos = token;
32823 try { return !jj_3_8(); }
32824 catch(LookaheadSuccess ls) { return true; }
32825 finally { jj_save(7, xla); }
32826 }
32827
32828 private boolean jj_2_9(int xla) {
32829 jj_la = xla; jj_lastpos = jj_scanpos = token;
32830 try { return !jj_3_9(); }
32831 catch(LookaheadSuccess ls) { return true; }
32832 finally { jj_save(8, xla); }
32833 }
32834
32835 private boolean jj_2_10(int xla) {
32836 jj_la = xla; jj_lastpos = jj_scanpos = token;
32837 try { return !jj_3_10(); }
32838 catch(LookaheadSuccess ls) { return true; }
32839 finally { jj_save(9, xla); }
32840 }
32841
32842 private boolean jj_2_11(int xla) {
32843 jj_la = xla; jj_lastpos = jj_scanpos = token;
32844 try { return !jj_3_11(); }
32845 catch(LookaheadSuccess ls) { return true; }
32846 finally { jj_save(10, xla); }
32847 }
32848
32849 private boolean jj_2_12(int xla) {
32850 jj_la = xla; jj_lastpos = jj_scanpos = token;
32851 try { return !jj_3_12(); }
32852 catch(LookaheadSuccess ls) { return true; }
32853 finally { jj_save(11, xla); }
32854 }
32855
32856 private boolean jj_2_13(int xla) {
32857 jj_la = xla; jj_lastpos = jj_scanpos = token;
32858 try { return !jj_3_13(); }
32859 catch(LookaheadSuccess ls) { return true; }
32860 finally { jj_save(12, xla); }
32861 }
32862
32863 private boolean jj_2_14(int xla) {
32864 jj_la = xla; jj_lastpos = jj_scanpos = token;
32865 try { return !jj_3_14(); }
32866 catch(LookaheadSuccess ls) { return true; }
32867 finally { jj_save(13, xla); }
32868 }
32869
32870 private boolean jj_2_15(int xla) {
32871 jj_la = xla; jj_lastpos = jj_scanpos = token;
32872 try { return !jj_3_15(); }
32873 catch(LookaheadSuccess ls) { return true; }
32874 finally { jj_save(14, xla); }
32875 }
32876
32877 private boolean jj_2_16(int xla) {
32878 jj_la = xla; jj_lastpos = jj_scanpos = token;
32879 try { return !jj_3_16(); }
32880 catch(LookaheadSuccess ls) { return true; }
32881 finally { jj_save(15, xla); }
32882 }
32883
32884 private boolean jj_2_17(int xla) {
32885 jj_la = xla; jj_lastpos = jj_scanpos = token;
32886 try { return !jj_3_17(); }
32887 catch(LookaheadSuccess ls) { return true; }
32888 finally { jj_save(16, xla); }
32889 }
32890
32891 private boolean jj_2_18(int xla) {
32892 jj_la = xla; jj_lastpos = jj_scanpos = token;
32893 try { return !jj_3_18(); }
32894 catch(LookaheadSuccess ls) { return true; }
32895 finally { jj_save(17, xla); }
32896 }
32897
32898 private boolean jj_2_19(int xla) {
32899 jj_la = xla; jj_lastpos = jj_scanpos = token;
32900 try { return !jj_3_19(); }
32901 catch(LookaheadSuccess ls) { return true; }
32902 finally { jj_save(18, xla); }
32903 }
32904
32905 private boolean jj_2_20(int xla) {
32906 jj_la = xla; jj_lastpos = jj_scanpos = token;
32907 try { return !jj_3_20(); }
32908 catch(LookaheadSuccess ls) { return true; }
32909 finally { jj_save(19, xla); }
32910 }
32911
32912 private boolean jj_2_21(int xla) {
32913 jj_la = xla; jj_lastpos = jj_scanpos = token;
32914 try { return !jj_3_21(); }
32915 catch(LookaheadSuccess ls) { return true; }
32916 finally { jj_save(20, xla); }
32917 }
32918
32919 private boolean jj_2_22(int xla) {
32920 jj_la = xla; jj_lastpos = jj_scanpos = token;
32921 try { return !jj_3_22(); }
32922 catch(LookaheadSuccess ls) { return true; }
32923 finally { jj_save(21, xla); }
32924 }
32925
32926 private boolean jj_2_23(int xla) {
32927 jj_la = xla; jj_lastpos = jj_scanpos = token;
32928 try { return !jj_3_23(); }
32929 catch(LookaheadSuccess ls) { return true; }
32930 finally { jj_save(22, xla); }
32931 }
32932
32933 private boolean jj_2_24(int xla) {
32934 jj_la = xla; jj_lastpos = jj_scanpos = token;
32935 try { return !jj_3_24(); }
32936 catch(LookaheadSuccess ls) { return true; }
32937 finally { jj_save(23, xla); }
32938 }
32939
32940 private boolean jj_2_25(int xla) {
32941 jj_la = xla; jj_lastpos = jj_scanpos = token;
32942 try { return !jj_3_25(); }
32943 catch(LookaheadSuccess ls) { return true; }
32944 finally { jj_save(24, xla); }
32945 }
32946
32947 private boolean jj_2_26(int xla) {
32948 jj_la = xla; jj_lastpos = jj_scanpos = token;
32949 try { return !jj_3_26(); }
32950 catch(LookaheadSuccess ls) { return true; }
32951 finally { jj_save(25, xla); }
32952 }
32953
32954 private boolean jj_2_27(int xla) {
32955 jj_la = xla; jj_lastpos = jj_scanpos = token;
32956 try { return !jj_3_27(); }
32957 catch(LookaheadSuccess ls) { return true; }
32958 finally { jj_save(26, xla); }
32959 }
32960
32961 private boolean jj_2_28(int xla) {
32962 jj_la = xla; jj_lastpos = jj_scanpos = token;
32963 try { return !jj_3_28(); }
32964 catch(LookaheadSuccess ls) { return true; }
32965 finally { jj_save(27, xla); }
32966 }
32967
32968 private boolean jj_2_29(int xla) {
32969 jj_la = xla; jj_lastpos = jj_scanpos = token;
32970 try { return !jj_3_29(); }
32971 catch(LookaheadSuccess ls) { return true; }
32972 finally { jj_save(28, xla); }
32973 }
32974
32975 private boolean jj_2_30(int xla) {
32976 jj_la = xla; jj_lastpos = jj_scanpos = token;
32977 try { return !jj_3_30(); }
32978 catch(LookaheadSuccess ls) { return true; }
32979 finally { jj_save(29, xla); }
32980 }
32981
32982 private boolean jj_2_31(int xla) {
32983 jj_la = xla; jj_lastpos = jj_scanpos = token;
32984 try { return !jj_3_31(); }
32985 catch(LookaheadSuccess ls) { return true; }
32986 finally { jj_save(30, xla); }
32987 }
32988
32989 private boolean jj_2_32(int xla) {
32990 jj_la = xla; jj_lastpos = jj_scanpos = token;
32991 try { return !jj_3_32(); }
32992 catch(LookaheadSuccess ls) { return true; }
32993 finally { jj_save(31, xla); }
32994 }
32995
32996 private boolean jj_2_33(int xla) {
32997 jj_la = xla; jj_lastpos = jj_scanpos = token;
32998 try { return !jj_3_33(); }
32999 catch(LookaheadSuccess ls) { return true; }
33000 finally { jj_save(32, xla); }
33001 }
33002
33003 private boolean jj_2_34(int xla) {
33004 jj_la = xla; jj_lastpos = jj_scanpos = token;
33005 try { return !jj_3_34(); }
33006 catch(LookaheadSuccess ls) { return true; }
33007 finally { jj_save(33, xla); }
33008 }
33009
33010 private boolean jj_2_35(int xla) {
33011 jj_la = xla; jj_lastpos = jj_scanpos = token;
33012 try { return !jj_3_35(); }
33013 catch(LookaheadSuccess ls) { return true; }
33014 finally { jj_save(34, xla); }
33015 }
33016
33017 private boolean jj_2_36(int xla) {
33018 jj_la = xla; jj_lastpos = jj_scanpos = token;
33019 try { return !jj_3_36(); }
33020 catch(LookaheadSuccess ls) { return true; }
33021 finally { jj_save(35, xla); }
33022 }
33023
33024 private boolean jj_2_37(int xla) {
33025 jj_la = xla; jj_lastpos = jj_scanpos = token;
33026 try { return !jj_3_37(); }
33027 catch(LookaheadSuccess ls) { return true; }
33028 finally { jj_save(36, xla); }
33029 }
33030
33031 private boolean jj_2_38(int xla) {
33032 jj_la = xla; jj_lastpos = jj_scanpos = token;
33033 try { return !jj_3_38(); }
33034 catch(LookaheadSuccess ls) { return true; }
33035 finally { jj_save(37, xla); }
33036 }
33037
33038 private boolean jj_2_39(int xla) {
33039 jj_la = xla; jj_lastpos = jj_scanpos = token;
33040 try { return !jj_3_39(); }
33041 catch(LookaheadSuccess ls) { return true; }
33042 finally { jj_save(38, xla); }
33043 }
33044
33045 private boolean jj_2_40(int xla) {
33046 jj_la = xla; jj_lastpos = jj_scanpos = token;
33047 try { return !jj_3_40(); }
33048 catch(LookaheadSuccess ls) { return true; }
33049 finally { jj_save(39, xla); }
33050 }
33051
33052 private boolean jj_2_41(int xla) {
33053 jj_la = xla; jj_lastpos = jj_scanpos = token;
33054 try { return !jj_3_41(); }
33055 catch(LookaheadSuccess ls) { return true; }
33056 finally { jj_save(40, xla); }
33057 }
33058
33059 private boolean jj_2_42(int xla) {
33060 jj_la = xla; jj_lastpos = jj_scanpos = token;
33061 try { return !jj_3_42(); }
33062 catch(LookaheadSuccess ls) { return true; }
33063 finally { jj_save(41, xla); }
33064 }
33065
33066 private boolean jj_2_43(int xla) {
33067 jj_la = xla; jj_lastpos = jj_scanpos = token;
33068 try { return !jj_3_43(); }
33069 catch(LookaheadSuccess ls) { return true; }
33070 finally { jj_save(42, xla); }
33071 }
33072
33073 private boolean jj_2_44(int xla) {
33074 jj_la = xla; jj_lastpos = jj_scanpos = token;
33075 try { return !jj_3_44(); }
33076 catch(LookaheadSuccess ls) { return true; }
33077 finally { jj_save(43, xla); }
33078 }
33079
33080 private boolean jj_2_45(int xla) {
33081 jj_la = xla; jj_lastpos = jj_scanpos = token;
33082 try { return !jj_3_45(); }
33083 catch(LookaheadSuccess ls) { return true; }
33084 finally { jj_save(44, xla); }
33085 }
33086
33087 private boolean jj_2_46(int xla) {
33088 jj_la = xla; jj_lastpos = jj_scanpos = token;
33089 try { return !jj_3_46(); }
33090 catch(LookaheadSuccess ls) { return true; }
33091 finally { jj_save(45, xla); }
33092 }
33093
33094 private boolean jj_2_47(int xla) {
33095 jj_la = xla; jj_lastpos = jj_scanpos = token;
33096 try { return !jj_3_47(); }
33097 catch(LookaheadSuccess ls) { return true; }
33098 finally { jj_save(46, xla); }
33099 }
33100
33101 private boolean jj_2_48(int xla) {
33102 jj_la = xla; jj_lastpos = jj_scanpos = token;
33103 try { return !jj_3_48(); }
33104 catch(LookaheadSuccess ls) { return true; }
33105 finally { jj_save(47, xla); }
33106 }
33107
33108 private boolean jj_2_49(int xla) {
33109 jj_la = xla; jj_lastpos = jj_scanpos = token;
33110 try { return !jj_3_49(); }
33111 catch(LookaheadSuccess ls) { return true; }
33112 finally { jj_save(48, xla); }
33113 }
33114
33115 private boolean jj_2_50(int xla) {
33116 jj_la = xla; jj_lastpos = jj_scanpos = token;
33117 try { return !jj_3_50(); }
33118 catch(LookaheadSuccess ls) { return true; }
33119 finally { jj_save(49, xla); }
33120 }
33121
33122 private boolean jj_2_51(int xla) {
33123 jj_la = xla; jj_lastpos = jj_scanpos = token;
33124 try { return !jj_3_51(); }
33125 catch(LookaheadSuccess ls) { return true; }
33126 finally { jj_save(50, xla); }
33127 }
33128
33129 private boolean jj_2_52(int xla) {
33130 jj_la = xla; jj_lastpos = jj_scanpos = token;
33131 try { return !jj_3_52(); }
33132 catch(LookaheadSuccess ls) { return true; }
33133 finally { jj_save(51, xla); }
33134 }
33135
33136 private boolean jj_2_53(int xla) {
33137 jj_la = xla; jj_lastpos = jj_scanpos = token;
33138 try { return !jj_3_53(); }
33139 catch(LookaheadSuccess ls) { return true; }
33140 finally { jj_save(52, xla); }
33141 }
33142
33143 private boolean jj_2_54(int xla) {
33144 jj_la = xla; jj_lastpos = jj_scanpos = token;
33145 try { return !jj_3_54(); }
33146 catch(LookaheadSuccess ls) { return true; }
33147 finally { jj_save(53, xla); }
33148 }
33149
33150 private boolean jj_2_55(int xla) {
33151 jj_la = xla; jj_lastpos = jj_scanpos = token;
33152 try { return !jj_3_55(); }
33153 catch(LookaheadSuccess ls) { return true; }
33154 finally { jj_save(54, xla); }
33155 }
33156
33157 private boolean jj_2_56(int xla) {
33158 jj_la = xla; jj_lastpos = jj_scanpos = token;
33159 try { return !jj_3_56(); }
33160 catch(LookaheadSuccess ls) { return true; }
33161 finally { jj_save(55, xla); }
33162 }
33163
33164 private boolean jj_2_57(int xla) {
33165 jj_la = xla; jj_lastpos = jj_scanpos = token;
33166 try { return !jj_3_57(); }
33167 catch(LookaheadSuccess ls) { return true; }
33168 finally { jj_save(56, xla); }
33169 }
33170
33171 private boolean jj_2_58(int xla) {
33172 jj_la = xla; jj_lastpos = jj_scanpos = token;
33173 try { return !jj_3_58(); }
33174 catch(LookaheadSuccess ls) { return true; }
33175 finally { jj_save(57, xla); }
33176 }
33177
33178 private boolean jj_2_59(int xla) {
33179 jj_la = xla; jj_lastpos = jj_scanpos = token;
33180 try { return !jj_3_59(); }
33181 catch(LookaheadSuccess ls) { return true; }
33182 finally { jj_save(58, xla); }
33183 }
33184
33185 private boolean jj_2_60(int xla) {
33186 jj_la = xla; jj_lastpos = jj_scanpos = token;
33187 try { return !jj_3_60(); }
33188 catch(LookaheadSuccess ls) { return true; }
33189 finally { jj_save(59, xla); }
33190 }
33191
33192 private boolean jj_2_61(int xla) {
33193 jj_la = xla; jj_lastpos = jj_scanpos = token;
33194 try { return !jj_3_61(); }
33195 catch(LookaheadSuccess ls) { return true; }
33196 finally { jj_save(60, xla); }
33197 }
33198
33199 private boolean jj_2_62(int xla) {
33200 jj_la = xla; jj_lastpos = jj_scanpos = token;
33201 try { return !jj_3_62(); }
33202 catch(LookaheadSuccess ls) { return true; }
33203 finally { jj_save(61, xla); }
33204 }
33205
33206 private boolean jj_2_63(int xla) {
33207 jj_la = xla; jj_lastpos = jj_scanpos = token;
33208 try { return !jj_3_63(); }
33209 catch(LookaheadSuccess ls) { return true; }
33210 finally { jj_save(62, xla); }
33211 }
33212
33213 private boolean jj_2_64(int xla) {
33214 jj_la = xla; jj_lastpos = jj_scanpos = token;
33215 try { return !jj_3_64(); }
33216 catch(LookaheadSuccess ls) { return true; }
33217 finally { jj_save(63, xla); }
33218 }
33219
33220 private boolean jj_2_65(int xla) {
33221 jj_la = xla; jj_lastpos = jj_scanpos = token;
33222 try { return !jj_3_65(); }
33223 catch(LookaheadSuccess ls) { return true; }
33224 finally { jj_save(64, xla); }
33225 }
33226
33227 private boolean jj_2_66(int xla) {
33228 jj_la = xla; jj_lastpos = jj_scanpos = token;
33229 try { return !jj_3_66(); }
33230 catch(LookaheadSuccess ls) { return true; }
33231 finally { jj_save(65, xla); }
33232 }
33233
33234 private boolean jj_2_67(int xla) {
33235 jj_la = xla; jj_lastpos = jj_scanpos = token;
33236 try { return !jj_3_67(); }
33237 catch(LookaheadSuccess ls) { return true; }
33238 finally { jj_save(66, xla); }
33239 }
33240
33241 private boolean jj_2_68(int xla) {
33242 jj_la = xla; jj_lastpos = jj_scanpos = token;
33243 try { return !jj_3_68(); }
33244 catch(LookaheadSuccess ls) { return true; }
33245 finally { jj_save(67, xla); }
33246 }
33247
33248 private boolean jj_2_69(int xla) {
33249 jj_la = xla; jj_lastpos = jj_scanpos = token;
33250 try { return !jj_3_69(); }
33251 catch(LookaheadSuccess ls) { return true; }
33252 finally { jj_save(68, xla); }
33253 }
33254
33255 private boolean jj_2_70(int xla) {
33256 jj_la = xla; jj_lastpos = jj_scanpos = token;
33257 try { return !jj_3_70(); }
33258 catch(LookaheadSuccess ls) { return true; }
33259 finally { jj_save(69, xla); }
33260 }
33261
33262 private boolean jj_2_71(int xla) {
33263 jj_la = xla; jj_lastpos = jj_scanpos = token;
33264 try { return !jj_3_71(); }
33265 catch(LookaheadSuccess ls) { return true; }
33266 finally { jj_save(70, xla); }
33267 }
33268
33269 private boolean jj_2_72(int xla) {
33270 jj_la = xla; jj_lastpos = jj_scanpos = token;
33271 try { return !jj_3_72(); }
33272 catch(LookaheadSuccess ls) { return true; }
33273 finally { jj_save(71, xla); }
33274 }
33275
33276 private boolean jj_2_73(int xla) {
33277 jj_la = xla; jj_lastpos = jj_scanpos = token;
33278 try { return !jj_3_73(); }
33279 catch(LookaheadSuccess ls) { return true; }
33280 finally { jj_save(72, xla); }
33281 }
33282
33283 private boolean jj_2_74(int xla) {
33284 jj_la = xla; jj_lastpos = jj_scanpos = token;
33285 try { return !jj_3_74(); }
33286 catch(LookaheadSuccess ls) { return true; }
33287 finally { jj_save(73, xla); }
33288 }
33289
33290 private boolean jj_2_75(int xla) {
33291 jj_la = xla; jj_lastpos = jj_scanpos = token;
33292 try { return !jj_3_75(); }
33293 catch(LookaheadSuccess ls) { return true; }
33294 finally { jj_save(74, xla); }
33295 }
33296
33297 private boolean jj_2_76(int xla) {
33298 jj_la = xla; jj_lastpos = jj_scanpos = token;
33299 try { return !jj_3_76(); }
33300 catch(LookaheadSuccess ls) { return true; }
33301 finally { jj_save(75, xla); }
33302 }
33303
33304 private boolean jj_2_77(int xla) {
33305 jj_la = xla; jj_lastpos = jj_scanpos = token;
33306 try { return !jj_3_77(); }
33307 catch(LookaheadSuccess ls) { return true; }
33308 finally { jj_save(76, xla); }
33309 }
33310
33311 private boolean jj_2_78(int xla) {
33312 jj_la = xla; jj_lastpos = jj_scanpos = token;
33313 try { return !jj_3_78(); }
33314 catch(LookaheadSuccess ls) { return true; }
33315 finally { jj_save(77, xla); }
33316 }
33317
33318 private boolean jj_2_79(int xla) {
33319 jj_la = xla; jj_lastpos = jj_scanpos = token;
33320 try { return !jj_3_79(); }
33321 catch(LookaheadSuccess ls) { return true; }
33322 finally { jj_save(78, xla); }
33323 }
33324
33325 private boolean jj_2_80(int xla) {
33326 jj_la = xla; jj_lastpos = jj_scanpos = token;
33327 try { return !jj_3_80(); }
33328 catch(LookaheadSuccess ls) { return true; }
33329 finally { jj_save(79, xla); }
33330 }
33331
33332 private boolean jj_2_81(int xla) {
33333 jj_la = xla; jj_lastpos = jj_scanpos = token;
33334 try { return !jj_3_81(); }
33335 catch(LookaheadSuccess ls) { return true; }
33336 finally { jj_save(80, xla); }
33337 }
33338
33339 private boolean jj_2_82(int xla) {
33340 jj_la = xla; jj_lastpos = jj_scanpos = token;
33341 try { return !jj_3_82(); }
33342 catch(LookaheadSuccess ls) { return true; }
33343 finally { jj_save(81, xla); }
33344 }
33345
33346 private boolean jj_2_83(int xla) {
33347 jj_la = xla; jj_lastpos = jj_scanpos = token;
33348 try { return !jj_3_83(); }
33349 catch(LookaheadSuccess ls) { return true; }
33350 finally { jj_save(82, xla); }
33351 }
33352
33353 private boolean jj_2_84(int xla) {
33354 jj_la = xla; jj_lastpos = jj_scanpos = token;
33355 try { return !jj_3_84(); }
33356 catch(LookaheadSuccess ls) { return true; }
33357 finally { jj_save(83, xla); }
33358 }
33359
33360 private boolean jj_2_85(int xla) {
33361 jj_la = xla; jj_lastpos = jj_scanpos = token;
33362 try { return !jj_3_85(); }
33363 catch(LookaheadSuccess ls) { return true; }
33364 finally { jj_save(84, xla); }
33365 }
33366
33367 private boolean jj_3R_269() {
33368 Token xsp;
33369 xsp = jj_scanpos;
33370 if (jj_scan_token(93)) {
33371 jj_scanpos = xsp;
33372 if (jj_scan_token(144)) {
33373 jj_scanpos = xsp;
33374 if (jj_scan_token(297)) return true;
33375 }
33376 }
33377 return false;
33378 }
33379
33380 private boolean jj_3R_200() {
33381 if (jj_scan_token(LANGUAGE)) return true;
33382 Token xsp;
33383 xsp = jj_scanpos;
33384 if (jj_scan_token(420)) {
33385 jj_scanpos = xsp;
33386 if (jj_scan_token(154)) return true;
33387 }
33388 return false;
33389 }
33390
33391 private boolean jj_3_77() {
33392 if (jj_3R_124()) return true;
33393 if (jj_scan_token(3)) return true;
33394 return false;
33395 }
33396
33397 private boolean jj_3R_565() {
33398 Token xsp;
33399 xsp = jj_scanpos;
33400 if (jj_scan_token(183)) jj_scanpos = xsp;
33401 if (jj_scan_token(NULL)) return true;
33402 return false;
33403 }
33404
33405 private boolean jj_3R_179() {
33406 Token xsp;
33407 xsp = jj_scanpos;
33408 if (jj_3_77()) jj_scanpos = xsp;
33409 if (jj_3R_124()) return true;
33410 return false;
33411 }
33412
33413 private boolean jj_3_78() {
33414 if (jj_scan_token(NESTED)) return true;
33415 if (jj_scan_token(TABLE)) return true;
33416 return false;
33417 }
33418
33419 private boolean jj_3R_530() {
33420 if (jj_scan_token(6)) return true;
33421 if (jj_3R_234()) return true;
33422 return false;
33423 }
33424
33425 private boolean jj_3R_525() {
33426 if (jj_scan_token(VARYING)) return true;
33427 if (jj_scan_token(ARRAY)) return true;
33428 return false;
33429 }
33430
33431 private boolean jj_3R_178() {
33432 if (jj_scan_token(OR)) return true;
33433 Token xsp;
33434 xsp = jj_scanpos;
33435 if (jj_3R_269()) {
33436 jj_scanpos = xsp;
33437 if (jj_3R_270()) return true;
33438 }
33439 return false;
33440 }
33441
33442 private boolean jj_3R_529() {
33443 if (jj_scan_token(RETURN)) return true;
33444 if (jj_3R_236()) return true;
33445 return false;
33446 }
33447
33448 private boolean jj_3R_176() {
33449 Token xsp;
33450 xsp = jj_scanpos;
33451 if (jj_scan_token(93)) {
33452 jj_scanpos = xsp;
33453 if (jj_scan_token(144)) {
33454 jj_scanpos = xsp;
33455 if (jj_scan_token(297)) return true;
33456 }
33457 }
33458 xsp = jj_scanpos;
33459 if (jj_3_74()) jj_scanpos = xsp;
33460 return false;
33461 }
33462
33463 private boolean jj_3R_527() {
33464 if (jj_scan_token(NOT)) return true;
33465 if (jj_scan_token(NULL)) return true;
33466 return false;
33467 }
33468
33469 private boolean jj_3R_266() {
33470 if (jj_scan_token(OR)) return true;
33471 if (jj_scan_token(REPLACE)) return true;
33472 return false;
33473 }
33474
33475 private boolean jj_3R_123() {
33476 Token xsp;
33477 xsp = jj_scanpos;
33478 if (jj_scan_token(114)) {
33479 jj_scanpos = xsp;
33480 if (jj_3R_200()) return true;
33481 }
33482 while (true) {
33483 xsp = jj_scanpos;
33484 if (jj_3R_201()) { jj_scanpos = xsp; break; }
33485 }
33486 return false;
33487 }
33488
33489 private boolean jj_3R_499() {
33490 if (jj_3R_236()) return true;
33491 return false;
33492 }
33493
33494 private boolean jj_3R_175() {
33495 if (jj_scan_token(CREATE)) return true;
33496 Token xsp;
33497 xsp = jj_scanpos;
33498 if (jj_3R_266()) jj_scanpos = xsp;
33499 xsp = jj_scanpos;
33500 if (jj_3R_267()) jj_scanpos = xsp;
33501 return false;
33502 }
33503
33504 private boolean jj_3R_498() {
33505 if (jj_scan_token(5)) return true;
33506 if (jj_3R_234()) return true;
33507 Token xsp;
33508 while (true) {
33509 xsp = jj_scanpos;
33510 if (jj_3R_530()) { jj_scanpos = xsp; break; }
33511 }
33512 if (jj_scan_token(7)) return true;
33513 return false;
33514 }
33515
33516 private boolean jj_3R_108() {
33517 Token xsp;
33518 xsp = jj_scanpos;
33519 if (jj_3R_175()) jj_scanpos = xsp;
33520 if (jj_scan_token(TRIGGER)) return true;
33521 if (jj_3R_155()) return true;
33522 xsp = jj_scanpos;
33523 if (jj_scan_token(322)) {
33524 jj_scanpos = xsp;
33525 if (jj_scan_token(321)) {
33526 jj_scanpos = xsp;
33527 if (jj_scan_token(323)) {
33528 jj_scanpos = xsp;
33529 if (jj_scan_token(121)) return true;
33530 }
33531 }
33532 }
33533 xsp = jj_scanpos;
33534 if (jj_3R_176()) {
33535 jj_scanpos = xsp;
33536 if (jj_3R_177()) return true;
33537 }
33538 while (true) {
33539 xsp = jj_scanpos;
33540 if (jj_3R_178()) { jj_scanpos = xsp; break; }
33541 }
33542 if (jj_scan_token(ON)) return true;
33543 xsp = jj_scanpos;
33544 if (jj_scan_token(348)) {
33545 jj_scanpos = xsp;
33546 if (jj_3_78()) {
33547 jj_scanpos = xsp;
33548 if (jj_3R_179()) return true;
33549 }
33550 }
33551 return false;
33552 }
33553
33554 private boolean jj_3R_497() {
33555 if (jj_scan_token(REF)) return true;
33556 if (jj_scan_token(CURSOR)) return true;
33557 Token xsp;
33558 xsp = jj_scanpos;
33559 if (jj_3R_529()) jj_scanpos = xsp;
33560 return false;
33561 }
33562
33563 private boolean jj_3R_522() {
33564 if (jj_3R_124()) return true;
33565 if (jj_3R_236()) return true;
33566 Token xsp;
33567 xsp = jj_scanpos;
33568 if (jj_3R_565()) jj_scanpos = xsp;
33569 xsp = jj_scanpos;
33570 if (jj_3R_566()) jj_scanpos = xsp;
33571 return false;
33572 }
33573
33574 private boolean jj_3R_496() {
33575 Token xsp;
33576 xsp = jj_scanpos;
33577 if (jj_scan_token(271)) {
33578 jj_scanpos = xsp;
33579 if (jj_scan_token(310)) {
33580 jj_scanpos = xsp;
33581 if (jj_3R_525()) return true;
33582 }
33583 }
33584 xsp = jj_scanpos;
33585 if (jj_3R_526()) jj_scanpos = xsp;
33586 if (jj_scan_token(OF)) return true;
33587 if (jj_3R_236()) return true;
33588 xsp = jj_scanpos;
33589 if (jj_3R_527()) jj_scanpos = xsp;
33590 xsp = jj_scanpos;
33591 if (jj_3R_528()) jj_scanpos = xsp;
33592 return false;
33593 }
33594
33595 private boolean jj_3R_495() {
33596 if (jj_scan_token(RECORD)) return true;
33597 if (jj_scan_token(5)) return true;
33598 if (jj_3R_522()) return true;
33599 Token xsp;
33600 while (true) {
33601 xsp = jj_scanpos;
33602 if (jj_3R_524()) { jj_scanpos = xsp; break; }
33603 }
33604 if (jj_scan_token(7)) return true;
33605 return false;
33606 }
33607
33608 private boolean jj_3R_494() {
33609 if (jj_scan_token(OBJECT)) return true;
33610 if (jj_scan_token(5)) return true;
33611 if (jj_3R_522()) return true;
33612 Token xsp;
33613 while (true) {
33614 xsp = jj_scanpos;
33615 if (jj_3R_523()) { jj_scanpos = xsp; break; }
33616 }
33617 if (jj_scan_token(7)) return true;
33618 return false;
33619 }
33620
33621 private boolean jj_3R_645() {
33622 if (jj_3R_174()) return true;
33623 return false;
33624 }
33625
33626 private boolean jj_3_44() {
33627 if (jj_scan_token(NEW)) return true;
33628 Token xsp;
33629 xsp = jj_scanpos;
33630 if (jj_scan_token(68)) {
33631 jj_scanpos = xsp;
33632 if (jj_scan_token(191)) {
33633 jj_scanpos = xsp;
33634 if (jj_scan_token(190)) {
33635 jj_scanpos = xsp;
33636 if (jj_scan_token(189)) {
33637 jj_scanpos = xsp;
33638 if (jj_scan_token(188)) {
33639 jj_scanpos = xsp;
33640 if (jj_scan_token(192)) return true;
33641 }
33642 }
33643 }
33644 }
33645 }
33646 return false;
33647 }
33648
33649 private boolean jj_3R_595() {
33650 if (jj_3R_174()) return true;
33651 return false;
33652 }
33653
33654 private boolean jj_3R_646() {
33655 Token xsp;
33656 xsp = jj_scanpos;
33657 if (jj_scan_token(137)) {
33658 jj_scanpos = xsp;
33659 if (jj_scan_token(207)) {
33660 jj_scanpos = xsp;
33661 if (jj_scan_token(138)) return true;
33662 }
33663 }
33664 return false;
33665 }
33666
33667 private boolean jj_3R_493() {
33668 if (jj_scan_token(NOT)) return true;
33669 if (jj_scan_token(NULL)) return true;
33670 return false;
33671 }
33672
33673 private boolean jj_3R_521() {
33674 if (jj_scan_token(RANGE)) return true;
33675 if (jj_3R_484()) return true;
33676 if (jj_scan_token(12)) return true;
33677 if (jj_3R_484()) return true;
33678 return false;
33679 }
33680
33681 private boolean jj_3R_520() {
33682 if (jj_scan_token(5)) return true;
33683 if (jj_scan_token(IDENTIFIER)) return true;
33684 if (jj_scan_token(7)) return true;
33685 return false;
33686 }
33687
33688 private boolean jj_3R_492() {
33689 Token xsp;
33690 xsp = jj_scanpos;
33691 if (jj_3R_520()) {
33692 jj_scanpos = xsp;
33693 if (jj_3R_521()) return true;
33694 }
33695 return false;
33696 }
33697
33698 private boolean jj_3R_647() {
33699 if (jj_scan_token(IN)) return true;
33700 Token xsp;
33701 xsp = jj_scanpos;
33702 if (jj_scan_token(207)) jj_scanpos = xsp;
33703 return false;
33704 }
33705
33706 private boolean jj_3R_644() {
33707 Token xsp;
33708 xsp = jj_scanpos;
33709 if (jj_3R_647()) {
33710 jj_scanpos = xsp;
33711 if (jj_scan_token(207)) return true;
33712 }
33713 return false;
33714 }
33715
33716 private boolean jj_3R_643() {
33717 if (jj_scan_token(6)) return true;
33718 Token xsp;
33719 xsp = jj_scanpos;
33720 if (jj_3R_646()) jj_scanpos = xsp;
33721 if (jj_3R_234()) return true;
33722 return false;
33723 }
33724
33725 private boolean jj_3R_244() {
33726 if (jj_scan_token(TYPE)) return true;
33727 if (jj_3R_120()) return true;
33728 Token xsp;
33729 xsp = jj_scanpos;
33730 if (jj_scan_token(152)) {
33731 jj_scanpos = xsp;
33732 if (jj_scan_token(51)) return true;
33733 }
33734 xsp = jj_scanpos;
33735 if (jj_3_44()) {
33736 jj_scanpos = xsp;
33737 if (jj_3R_494()) {
33738 jj_scanpos = xsp;
33739 if (jj_3R_495()) {
33740 jj_scanpos = xsp;
33741 if (jj_3R_496()) {
33742 jj_scanpos = xsp;
33743 if (jj_3R_497()) {
33744 jj_scanpos = xsp;
33745 if (jj_3R_498()) {
33746 jj_scanpos = xsp;
33747 if (jj_3R_499()) return true;
33748 }
33749 }
33750 }
33751 }
33752 }
33753 }
33754 return false;
33755 }
33756
33757 private boolean jj_3R_641() {
33758 if (jj_scan_token(6)) return true;
33759 if (jj_3R_234()) return true;
33760 return false;
33761 }
33762
33763 private boolean jj_3R_640() {
33764 if (jj_scan_token(6)) return true;
33765 Token xsp;
33766 xsp = jj_scanpos;
33767 if (jj_3R_644()) jj_scanpos = xsp;
33768 if (jj_3R_234()) return true;
33769 return false;
33770 }
33771
33772 private boolean jj_3R_243() {
33773 if (jj_scan_token(SUBTYPE)) return true;
33774 if (jj_3R_120()) return true;
33775 if (jj_scan_token(IS)) return true;
33776 if (jj_3R_236()) return true;
33777 Token xsp;
33778 xsp = jj_scanpos;
33779 if (jj_3R_492()) jj_scanpos = xsp;
33780 xsp = jj_scanpos;
33781 if (jj_3R_493()) jj_scanpos = xsp;
33782 return false;
33783 }
33784
33785 private boolean jj_3R_620() {
33786 if (jj_3R_174()) return true;
33787 return false;
33788 }
33789
33790 private boolean jj_3R_153() {
33791 Token xsp;
33792 xsp = jj_scanpos;
33793 if (jj_3R_243()) {
33794 jj_scanpos = xsp;
33795 if (jj_3R_244()) return true;
33796 }
33797 if (jj_scan_token(4)) return true;
33798 return false;
33799 }
33800
33801 private boolean jj_3R_556() {
33802 if (jj_scan_token(LIMIT)) return true;
33803 if (jj_3R_234()) return true;
33804 return false;
33805 }
33806
33807 private boolean jj_3R_597() {
33808 if (jj_scan_token(CC_ELSE)) return true;
33809 Token xsp;
33810 if (jj_3R_620()) return true;
33811 while (true) {
33812 xsp = jj_scanpos;
33813 if (jj_3R_620()) { jj_scanpos = xsp; break; }
33814 }
33815 return false;
33816 }
33817
33818 private boolean jj_3R_596() {
33819 if (jj_scan_token(CC_ELSIF)) return true;
33820 if (jj_3R_344()) return true;
33821 if (jj_scan_token(CC_THEN)) return true;
33822 Token xsp;
33823 if (jj_3R_645()) return true;
33824 while (true) {
33825 xsp = jj_scanpos;
33826 if (jj_3R_645()) { jj_scanpos = xsp; break; }
33827 }
33828 return false;
33829 }
33830
33831 private boolean jj_3R_457() {
33832 if (jj_scan_token(CC_ERROR)) return true;
33833 if (jj_3R_234()) return true;
33834 if (jj_scan_token(CC_END)) return true;
33835 return false;
33836 }
33837
33838 private boolean jj_3R_404() {
33839 if (jj_scan_token(INTERFACE)) return true;
33840 if (jj_scan_token(5)) return true;
33841 return false;
33842 }
33843
33844 private boolean jj_3R_403() {
33845 if (jj_scan_token(EXCEPTION_INIT)) return true;
33846 if (jj_scan_token(5)) return true;
33847 return false;
33848 }
33849
33850 private boolean jj_3R_456() {
33851 if (jj_scan_token(CC_IF)) return true;
33852 if (jj_3R_344()) return true;
33853 if (jj_scan_token(CC_THEN)) return true;
33854 Token xsp;
33855 while (true) {
33856 xsp = jj_scanpos;
33857 if (jj_3R_595()) { jj_scanpos = xsp; break; }
33858 }
33859 while (true) {
33860 xsp = jj_scanpos;
33861 if (jj_3R_596()) { jj_scanpos = xsp; break; }
33862 }
33863 while (true) {
33864 xsp = jj_scanpos;
33865 if (jj_3R_597()) { jj_scanpos = xsp; break; }
33866 }
33867 if (jj_scan_token(CC_END)) return true;
33868 return false;
33869 }
33870
33871 private boolean jj_3R_618() {
33872 Token xsp;
33873 xsp = jj_scanpos;
33874 if (jj_scan_token(137)) {
33875 jj_scanpos = xsp;
33876 if (jj_scan_token(207)) {
33877 jj_scanpos = xsp;
33878 if (jj_scan_token(138)) return true;
33879 }
33880 }
33881 return false;
33882 }
33883
33884 private boolean jj_3R_639() {
33885 if (jj_scan_token(6)) return true;
33886 if (jj_3R_295()) return true;
33887 return false;
33888 }
33889
33890 private boolean jj_3R_421() {
33891 Token xsp;
33892 xsp = jj_scanpos;
33893 if (jj_3R_456()) {
33894 jj_scanpos = xsp;
33895 if (jj_3R_457()) return true;
33896 }
33897 return false;
33898 }
33899
33900 private boolean jj_3R_402() {
33901 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33902 if (jj_scan_token(5)) return true;
33903 return false;
33904 }
33905
33906 private boolean jj_3R_619() {
33907 if (jj_scan_token(IN)) return true;
33908 Token xsp;
33909 xsp = jj_scanpos;
33910 if (jj_scan_token(207)) jj_scanpos = xsp;
33911 return false;
33912 }
33913
33914 private boolean jj_3R_594() {
33915 Token xsp;
33916 xsp = jj_scanpos;
33917 if (jj_3R_619()) {
33918 jj_scanpos = xsp;
33919 if (jj_scan_token(207)) return true;
33920 }
33921 return false;
33922 }
33923
33924 private boolean jj_3R_554() {
33925 if (jj_scan_token(BULK)) return true;
33926 if (jj_scan_token(COLLECT)) return true;
33927 return false;
33928 }
33929
33930 private boolean jj_3R_555() {
33931 if (jj_scan_token(6)) return true;
33932 if (jj_3R_234()) return true;
33933 return false;
33934 }
33935
33936 private boolean jj_3R_420() {
33937 if (jj_scan_token(PIPE)) return true;
33938 if (jj_scan_token(ROW)) return true;
33939 if (jj_3R_234()) return true;
33940 return false;
33941 }
33942
33943 private boolean jj_3R_593() {
33944 if (jj_scan_token(USING)) return true;
33945 Token xsp;
33946 xsp = jj_scanpos;
33947 if (jj_3R_618()) jj_scanpos = xsp;
33948 if (jj_3R_234()) return true;
33949 while (true) {
33950 xsp = jj_scanpos;
33951 if (jj_3R_643()) { jj_scanpos = xsp; break; }
33952 }
33953 return false;
33954 }
33955
33956 private boolean jj_3R_559() {
33957 Token xsp;
33958 xsp = jj_scanpos;
33959 if (jj_scan_token(237)) {
33960 jj_scanpos = xsp;
33961 if (jj_scan_token(238)) return true;
33962 }
33963 if (jj_scan_token(INTO)) return true;
33964 if (jj_3R_234()) return true;
33965 while (true) {
33966 xsp = jj_scanpos;
33967 if (jj_3R_641()) { jj_scanpos = xsp; break; }
33968 }
33969 return false;
33970 }
33971
33972 private boolean jj_3R_558() {
33973 if (jj_scan_token(USING)) return true;
33974 Token xsp;
33975 xsp = jj_scanpos;
33976 if (jj_3R_594()) jj_scanpos = xsp;
33977 if (jj_3R_234()) return true;
33978 while (true) {
33979 xsp = jj_scanpos;
33980 if (jj_3R_640()) { jj_scanpos = xsp; break; }
33981 }
33982 return false;
33983 }
33984
33985 private boolean jj_3R_352() {
33986 if (jj_scan_token(PRAGMA)) return true;
33987 Token xsp;
33988 xsp = jj_scanpos;
33989 if (jj_scan_token(38)) {
33990 jj_scanpos = xsp;
33991 if (jj_scan_token(41)) {
33992 jj_scanpos = xsp;
33993 if (jj_3R_402()) {
33994 jj_scanpos = xsp;
33995 if (jj_3R_403()) {
33996 jj_scanpos = xsp;
33997 if (jj_3R_404()) return true;
33998 }
33999 }
34000 }
34001 }
34002 return false;
34003 }
34004
34005 private boolean jj_3R_557() {
34006 if (jj_scan_token(INTO)) return true;
34007 if (jj_3R_295()) return true;
34008 Token xsp;
34009 while (true) {
34010 xsp = jj_scanpos;
34011 if (jj_3R_639()) { jj_scanpos = xsp; break; }
34012 }
34013 return false;
34014 }
34015
34016 private boolean jj_3R_452() {
34017 if (jj_scan_token(WHEN)) return true;
34018 if (jj_3R_234()) return true;
34019 return false;
34020 }
34021
34022 private boolean jj_3R_419() {
34023 if (jj_scan_token(EXECUTE)) return true;
34024 if (jj_scan_token(IMMEDIATE)) return true;
34025 if (jj_3R_234()) return true;
34026 Token xsp;
34027 xsp = jj_scanpos;
34028 if (jj_3R_557()) jj_scanpos = xsp;
34029 xsp = jj_scanpos;
34030 if (jj_3R_558()) jj_scanpos = xsp;
34031 xsp = jj_scanpos;
34032 if (jj_3R_559()) jj_scanpos = xsp;
34033 if (jj_scan_token(4)) return true;
34034 return false;
34035 }
34036
34037 private boolean jj_3R_455() {
34038 if (jj_scan_token(FOR)) return true;
34039 if (jj_3R_234()) return true;
34040 Token xsp;
34041 xsp = jj_scanpos;
34042 if (jj_3R_593()) jj_scanpos = xsp;
34043 return false;
34044 }
34045
34046 private boolean jj_3R_418() {
34047 if (jj_scan_token(FETCH)) return true;
34048 if (jj_3R_128()) return true;
34049 Token xsp;
34050 xsp = jj_scanpos;
34051 if (jj_3R_554()) jj_scanpos = xsp;
34052 if (jj_scan_token(INTO)) return true;
34053 if (jj_3R_234()) return true;
34054 while (true) {
34055 xsp = jj_scanpos;
34056 if (jj_3R_555()) { jj_scanpos = xsp; break; }
34057 }
34058 xsp = jj_scanpos;
34059 if (jj_3R_556()) jj_scanpos = xsp;
34060 return false;
34061 }
34062
34063 private boolean jj_3R_209() {
34064 if (jj_scan_token(WHEN)) return true;
34065 if (jj_3R_234()) return true;
34066 return false;
34067 }
34068
34069 private boolean jj_3R_454() {
34070 if (jj_3R_234()) return true;
34071 return false;
34072 }
34073
34074 private boolean jj_3R_148() {
34075 if (jj_3R_124()) return true;
34076 if (jj_3R_236()) return true;
34077 return false;
34078 }
34079
34080 private boolean jj_3R_417() {
34081 if (jj_scan_token(OPEN)) return true;
34082 Token xsp;
34083 xsp = jj_scanpos;
34084 if (jj_3R_454()) jj_scanpos = xsp;
34085 xsp = jj_scanpos;
34086 if (jj_3R_455()) jj_scanpos = xsp;
34087 return false;
34088 }
34089
34090 private boolean jj_3R_453() {
34091 if (jj_3R_128()) return true;
34092 return false;
34093 }
34094
34095 private boolean jj_3R_416() {
34096 if (jj_scan_token(CLOSE)) return true;
34097 if (jj_3R_128()) return true;
34098 return false;
34099 }
34100
34101 private boolean jj_3R_451() {
34102 if (jj_3R_143()) return true;
34103 return false;
34104 }
34105
34106 private boolean jj_3R_415() {
34107 if (jj_scan_token(RAISE)) return true;
34108 Token xsp;
34109 xsp = jj_scanpos;
34110 if (jj_3R_453()) jj_scanpos = xsp;
34111 return false;
34112 }
34113
34114 private boolean jj_3R_208() {
34115 if (jj_3R_143()) return true;
34116 return false;
34117 }
34118
34119 private boolean jj_3R_592() {
34120 if (jj_scan_token(12)) return true;
34121 if (jj_3R_234()) return true;
34122 return false;
34123 }
34124
34125 private boolean jj_3R_414() {
34126 if (jj_scan_token(EXIT)) return true;
34127 Token xsp;
34128 xsp = jj_scanpos;
34129 if (jj_3R_451()) jj_scanpos = xsp;
34130 xsp = jj_scanpos;
34131 if (jj_3R_452()) jj_scanpos = xsp;
34132 return false;
34133 }
34134
34135 private boolean jj_3R_450() {
34136 if (jj_3R_234()) return true;
34137 return false;
34138 }
34139
34140 private boolean jj_3R_132() {
34141 if (jj_scan_token(CONTINUE)) return true;
34142 Token xsp;
34143 xsp = jj_scanpos;
34144 if (jj_3R_208()) jj_scanpos = xsp;
34145 xsp = jj_scanpos;
34146 if (jj_3R_209()) jj_scanpos = xsp;
34147 return false;
34148 }
34149
34150 private boolean jj_3R_552() {
34151 if (jj_scan_token(SAVE)) return true;
34152 if (jj_scan_token(EXCEPTIONS)) return true;
34153 return false;
34154 }
34155
34156 private boolean jj_3R_551() {
34157 if (jj_3R_234()) return true;
34158 Token xsp;
34159 xsp = jj_scanpos;
34160 if (jj_3R_592()) jj_scanpos = xsp;
34161 return false;
34162 }
34163
34164 private boolean jj_3R_638() {
34165 if (jj_3R_174()) return true;
34166 return false;
34167 }
34168
34169 private boolean jj_3R_550() {
34170 Token xsp;
34171 xsp = jj_scanpos;
34172 if (jj_scan_token(140)) {
34173 jj_scanpos = xsp;
34174 if (jj_scan_token(289)) return true;
34175 }
34176 if (jj_scan_token(OF)) return true;
34177 if (jj_3R_234()) return true;
34178 return false;
34179 }
34180
34181 private boolean jj_3R_413() {
34182 if (jj_scan_token(RETURN)) return true;
34183 Token xsp;
34184 xsp = jj_scanpos;
34185 if (jj_3R_450()) jj_scanpos = xsp;
34186 return false;
34187 }
34188
34189 private boolean jj_3R_412() {
34190 if (jj_scan_token(GOTO)) return true;
34191 if (jj_3R_128()) return true;
34192 return false;
34193 }
34194
34195 private boolean jj_3R_356() {
34196 if (jj_scan_token(CASCADE)) return true;
34197 return false;
34198 }
34199
34200 private boolean jj_3R_315() {
34201 Token xsp;
34202 xsp = jj_scanpos;
34203 if (jj_scan_token(151)) {
34204 jj_scanpos = xsp;
34205 if (jj_3R_356()) return true;
34206 }
34207 return false;
34208 }
34209
34210 private boolean jj_3R_150() {
34211 if (jj_3R_239()) return true;
34212 return false;
34213 }
34214
34215 private boolean jj_3R_409() {
34216 if (jj_scan_token(FORALL)) return true;
34217 if (jj_3R_448()) return true;
34218 if (jj_scan_token(IN)) return true;
34219 Token xsp;
34220 xsp = jj_scanpos;
34221 if (jj_3R_550()) {
34222 jj_scanpos = xsp;
34223 if (jj_3R_551()) return true;
34224 }
34225 xsp = jj_scanpos;
34226 if (jj_3R_552()) jj_scanpos = xsp;
34227 if (jj_3R_405()) return true;
34228 return false;
34229 }
34230
34231 private boolean jj_3_73() {
34232 if (jj_3R_147()) return true;
34233 return false;
34234 }
34235
34236 private boolean jj_3R_549() {
34237 if (jj_scan_token(12)) return true;
34238 if (jj_3R_234()) return true;
34239 return false;
34240 }
34241
34242 private boolean jj_3R_149() {
34243 if (jj_scan_token(AUTHID)) return true;
34244 Token xsp;
34245 xsp = jj_scanpos;
34246 if (jj_scan_token(37)) {
34247 jj_scanpos = xsp;
34248 if (jj_scan_token(36)) return true;
34249 }
34250 return false;
34251 }
34252
34253 private boolean jj_3R_314() {
34254 Token xsp;
34255 xsp = jj_scanpos;
34256 if (jj_scan_token(183)) jj_scanpos = xsp;
34257 xsp = jj_scanpos;
34258 if (jj_scan_token(119)) {
34259 jj_scanpos = xsp;
34260 if (jj_scan_token(145)) {
34261 jj_scanpos = xsp;
34262 if (jj_scan_token(185)) return true;
34263 }
34264 }
34265 return false;
34266 }
34267
34268 private boolean jj_3_72() {
34269 if (jj_3R_147()) return true;
34270 return false;
34271 }
34272
34273 private boolean jj_3R_546() {
34274 if (jj_3R_174()) return true;
34275 return false;
34276 }
34277
34278 private boolean jj_3R_553() {
34279 if (jj_3R_174()) return true;
34280 return false;
34281 }
34282
34283 private boolean jj_3R_448() {
34284 if (jj_3R_124()) return true;
34285 return false;
34286 }
34287
34288 private boolean jj_3_71() {
34289 Token xsp;
34290 xsp = jj_scanpos;
34291 if (jj_3R_149()) {
34292 jj_scanpos = xsp;
34293 if (jj_3R_150()) return true;
34294 }
34295 return false;
34296 }
34297
34298 private boolean jj_3R_313() {
34299 if (jj_scan_token(REPLACE)) return true;
34300 return false;
34301 }
34302
34303 private boolean jj_3R_447() {
34304 if (jj_3R_124()) return true;
34305 return false;
34306 }
34307
34308 private boolean jj_3R_548() {
34309 if (jj_3R_486()) return true;
34310 return false;
34311 }
34312
34313 private boolean jj_3R_547() {
34314 if (jj_3R_591()) return true;
34315 return false;
34316 }
34317
34318 private boolean jj_3R_407() {
34319 if (jj_scan_token(IF)) return true;
34320 if (jj_3R_234()) return true;
34321 if (jj_scan_token(THEN)) return true;
34322 Token xsp;
34323 if (jj_3R_546()) return true;
34324 while (true) {
34325 xsp = jj_scanpos;
34326 if (jj_3R_546()) { jj_scanpos = xsp; break; }
34327 }
34328 while (true) {
34329 xsp = jj_scanpos;
34330 if (jj_3R_547()) { jj_scanpos = xsp; break; }
34331 }
34332 xsp = jj_scanpos;
34333 if (jj_3R_548()) jj_scanpos = xsp;
34334 if (jj_scan_token(END)) return true;
34335 if (jj_scan_token(IF)) return true;
34336 return false;
34337 }
34338
34339 private boolean jj_3R_642() {
34340 if (jj_3R_174()) return true;
34341 return false;
34342 }
34343
34344 private boolean jj_3R_411() {
34345 if (jj_scan_token(WHILE)) return true;
34346 if (jj_3R_234()) return true;
34347 if (jj_scan_token(LOOP)) return true;
34348 Token xsp;
34349 if (jj_3R_553()) return true;
34350 while (true) {
34351 xsp = jj_scanpos;
34352 if (jj_3R_553()) { jj_scanpos = xsp; break; }
34353 }
34354 if (jj_scan_token(END)) return true;
34355 if (jj_scan_token(LOOP)) return true;
34356 xsp = jj_scanpos;
34357 if (jj_scan_token(420)) jj_scanpos = xsp;
34358 return false;
34359 }
34360
34361 private boolean jj_3R_131() {
34362 if (jj_scan_token(LOCK)) return true;
34363 if (jj_scan_token(TABLE)) return true;
34364 return false;
34365 }
34366
34367 private boolean jj_3R_408() {
34368 if (jj_scan_token(FOR)) return true;
34369 if (jj_3R_447()) return true;
34370 if (jj_scan_token(IN)) return true;
34371 Token xsp;
34372 xsp = jj_scanpos;
34373 if (jj_scan_token(239)) jj_scanpos = xsp;
34374 if (jj_3R_234()) return true;
34375 xsp = jj_scanpos;
34376 if (jj_3R_549()) jj_scanpos = xsp;
34377 if (jj_scan_token(LOOP)) return true;
34378 if (jj_3R_638()) return true;
34379 while (true) {
34380 xsp = jj_scanpos;
34381 if (jj_3R_638()) { jj_scanpos = xsp; break; }
34382 }
34383 if (jj_scan_token(END)) return true;
34384 if (jj_scan_token(LOOP)) return true;
34385 xsp = jj_scanpos;
34386 if (jj_scan_token(420)) jj_scanpos = xsp;
34387 return false;
34388 }
34389
34390 private boolean jj_3R_616() {
34391 if (jj_3R_174()) return true;
34392 return false;
34393 }
34394
34395 private boolean jj_3R_449() {
34396 if (jj_3R_174()) return true;
34397 return false;
34398 }
34399
34400 private boolean jj_3R_410() {
34401 if (jj_scan_token(LOOP)) return true;
34402 Token xsp;
34403 if (jj_3R_449()) return true;
34404 while (true) {
34405 xsp = jj_scanpos;
34406 if (jj_3R_449()) { jj_scanpos = xsp; break; }
34407 }
34408 if (jj_scan_token(END)) return true;
34409 if (jj_scan_token(LOOP)) return true;
34410 xsp = jj_scanpos;
34411 if (jj_scan_token(420)) jj_scanpos = xsp;
34412 return false;
34413 }
34414
34415 private boolean jj_3R_130() {
34416 if (jj_scan_token(SET)) return true;
34417 if (jj_scan_token(TRANSACTION)) return true;
34418 return false;
34419 }
34420
34421 private boolean jj_3R_617() {
34422 if (jj_3R_174()) return true;
34423 return false;
34424 }
34425
34426 private boolean jj_3R_591() {
34427 if (jj_scan_token(ELSIF)) return true;
34428 if (jj_3R_234()) return true;
34429 if (jj_scan_token(THEN)) return true;
34430 Token xsp;
34431 if (jj_3R_642()) return true;
34432 while (true) {
34433 xsp = jj_scanpos;
34434 if (jj_3R_642()) { jj_scanpos = xsp; break; }
34435 }
34436 return false;
34437 }
34438
34439 private boolean jj_3R_486() {
34440 if (jj_scan_token(ELSE)) return true;
34441 Token xsp;
34442 if (jj_3R_617()) return true;
34443 while (true) {
34444 xsp = jj_scanpos;
34445 if (jj_3R_617()) { jj_scanpos = xsp; break; }
34446 }
34447 return false;
34448 }
34449
34450 private boolean jj_3R_485() {
34451 if (jj_scan_token(WHEN)) return true;
34452 if (jj_3R_234()) return true;
34453 if (jj_scan_token(THEN)) return true;
34454 Token xsp;
34455 if (jj_3R_616()) return true;
34456 while (true) {
34457 xsp = jj_scanpos;
34458 if (jj_3R_616()) { jj_scanpos = xsp; break; }
34459 }
34460 return false;
34461 }
34462
34463 private boolean jj_3R_444() {
34464 if (jj_3R_234()) return true;
34465 return false;
34466 }
34467
34468 private boolean jj_3R_355() {
34469 if (jj_scan_token(DROP)) return true;
34470 return false;
34471 }
34472
34473 private boolean jj_3R_446() {
34474 if (jj_3R_486()) return true;
34475 return false;
34476 }
34477
34478 private boolean jj_3R_445() {
34479 if (jj_3R_485()) return true;
34480 return false;
34481 }
34482
34483 private boolean jj_3R_406() {
34484 if (jj_scan_token(CASE)) return true;
34485 Token xsp;
34486 xsp = jj_scanpos;
34487 if (jj_3R_444()) jj_scanpos = xsp;
34488 while (true) {
34489 xsp = jj_scanpos;
34490 if (jj_3R_445()) { jj_scanpos = xsp; break; }
34491 }
34492 xsp = jj_scanpos;
34493 if (jj_3R_446()) jj_scanpos = xsp;
34494 if (jj_scan_token(END)) return true;
34495 if (jj_scan_token(CASE)) return true;
34496 xsp = jj_scanpos;
34497 if (jj_scan_token(420)) jj_scanpos = xsp;
34498 return false;
34499 }
34500
34501 private boolean jj_3R_357() {
34502 if (jj_3R_191()) return true;
34503 return false;
34504 }
34505
34506 private boolean jj_3R_354() {
34507 Token xsp;
34508 xsp = jj_scanpos;
34509 if (jj_scan_token(6)) jj_scanpos = xsp;
34510 xsp = jj_scanpos;
34511 if (jj_scan_token(44)) {
34512 jj_scanpos = xsp;
34513 if (jj_scan_token(170)) return true;
34514 }
34515 return false;
34516 }
34517
34518 private boolean jj_3R_312() {
34519 Token xsp;
34520 xsp = jj_scanpos;
34521 if (jj_3R_354()) {
34522 jj_scanpos = xsp;
34523 if (jj_3R_355()) return true;
34524 }
34525 return false;
34526 }
34527
34528 private boolean jj_3R_316() {
34529 Token xsp;
34530 if (jj_3R_357()) return true;
34531 while (true) {
34532 xsp = jj_scanpos;
34533 if (jj_3R_357()) { jj_scanpos = xsp; break; }
34534 }
34535 if (jj_3R_317()) return true;
34536 return false;
34537 }
34538
34539 private boolean jj_3R_308() {
34540 if (jj_3R_148()) return true;
34541 return false;
34542 }
34543
34544 private boolean jj_3R_260() {
34545 if (jj_scan_token(ALTER)) return true;
34546 if (jj_scan_token(TYPE)) return true;
34547 if (jj_3R_128()) return true;
34548 Token xsp;
34549 while (true) {
34550 xsp = jj_scanpos;
34551 if (jj_3R_312()) { jj_scanpos = xsp; break; }
34552 }
34553 xsp = jj_scanpos;
34554 if (jj_3R_313()) jj_scanpos = xsp;
34555 while (true) {
34556 xsp = jj_scanpos;
34557 if (jj_3R_314()) { jj_scanpos = xsp; break; }
34558 }
34559 xsp = jj_scanpos;
34560 if (jj_3R_315()) jj_scanpos = xsp;
34561 return false;
34562 }
34563
34564 private boolean jj_3_70() {
34565 if (jj_3R_148()) return true;
34566 return false;
34567 }
34568
34569 private boolean jj_3R_265() {
34570 if (jj_3R_317()) return true;
34571 return false;
34572 }
34573
34574 private boolean jj_3R_264() {
34575 if (jj_3R_316()) return true;
34576 return false;
34577 }
34578
34579 private boolean jj_3R_261() {
34580 if (jj_3R_260()) return true;
34581 return false;
34582 }
34583
34584 private boolean jj_3R_174() {
34585 Token xsp;
34586 xsp = jj_scanpos;
34587 if (jj_3R_264()) {
34588 jj_scanpos = xsp;
34589 if (jj_3R_265()) return true;
34590 }
34591 return false;
34592 }
34593
34594 private boolean jj_3R_168() {
34595 Token xsp;
34596 xsp = jj_scanpos;
34597 if (jj_scan_token(4)) {
34598 jj_scanpos = xsp;
34599 if (jj_scan_token(1)) return true;
34600 }
34601 while (true) {
34602 xsp = jj_scanpos;
34603 if (jj_3R_261()) { jj_scanpos = xsp; break; }
34604 }
34605 return false;
34606 }
34607
34608 private boolean jj_3R_167() {
34609 if (jj_3R_260()) return true;
34610 return false;
34611 }
34612
34613 private boolean jj_3R_377() {
34614 if (jj_3R_234()) return true;
34615 if (jj_scan_token(4)) return true;
34616 return false;
34617 }
34618
34619 private boolean jj_3R_310() {
34620 if (jj_3R_147()) return true;
34621 return false;
34622 }
34623
34624 private boolean jj_3R_311() {
34625 if (jj_3R_352()) return true;
34626 return false;
34627 }
34628
34629 private boolean jj_3R_376() {
34630 if (jj_3R_422()) return true;
34631 if (jj_scan_token(4)) return true;
34632 return false;
34633 }
34634
34635 private boolean jj_3R_375() {
34636 if (jj_3R_421()) return true;
34637 return false;
34638 }
34639
34640 private boolean jj_3R_374() {
34641 if (jj_3R_420()) return true;
34642 if (jj_scan_token(4)) return true;
34643 return false;
34644 }
34645
34646 private boolean jj_3R_443() {
34647 if (jj_scan_token(LOCK)) return true;
34648 if (jj_scan_token(TABLE)) return true;
34649 return false;
34650 }
34651
34652 private boolean jj_3R_373() {
34653 if (jj_3R_419()) return true;
34654 if (jj_scan_token(4)) return true;
34655 return false;
34656 }
34657
34658 private boolean jj_3R_372() {
34659 if (jj_3R_272()) return true;
34660 if (jj_scan_token(4)) return true;
34661 return false;
34662 }
34663
34664 private boolean jj_3R_371() {
34665 if (jj_3R_418()) return true;
34666 if (jj_scan_token(4)) return true;
34667 return false;
34668 }
34669
34670 private boolean jj_3R_370() {
34671 if (jj_3R_417()) return true;
34672 if (jj_scan_token(4)) return true;
34673 return false;
34674 }
34675
34676 private boolean jj_3R_166() {
34677 Token xsp;
34678 xsp = jj_scanpos;
34679 if (jj_scan_token(183)) jj_scanpos = xsp;
34680 xsp = jj_scanpos;
34681 if (jj_scan_token(119)) {
34682 jj_scanpos = xsp;
34683 if (jj_scan_token(145)) {
34684 jj_scanpos = xsp;
34685 if (jj_scan_token(185)) return true;
34686 }
34687 }
34688 return false;
34689 }
34690
34691 private boolean jj_3R_259() {
34692 if (jj_scan_token(6)) return true;
34693 Token xsp;
34694 xsp = jj_scanpos;
34695 if (jj_3R_310()) {
34696 jj_scanpos = xsp;
34697 if (jj_3_70()) {
34698 jj_scanpos = xsp;
34699 if (jj_3R_311()) return true;
34700 }
34701 }
34702 return false;
34703 }
34704
34705 private boolean jj_3R_369() {
34706 if (jj_3R_416()) return true;
34707 if (jj_scan_token(4)) return true;
34708 return false;
34709 }
34710
34711 private boolean jj_3R_309() {
34712 if (jj_3R_352()) return true;
34713 return false;
34714 }
34715
34716 private boolean jj_3R_368() {
34717 if (jj_3R_415()) return true;
34718 if (jj_scan_token(4)) return true;
34719 return false;
34720 }
34721
34722 private boolean jj_3R_367() {
34723 if (jj_3R_414()) return true;
34724 if (jj_scan_token(4)) return true;
34725 return false;
34726 }
34727
34728 private boolean jj_3R_366() {
34729 if (jj_3R_413()) return true;
34730 if (jj_scan_token(4)) return true;
34731 return false;
34732 }
34733
34734 private boolean jj_3_69() {
34735 if (jj_3R_147()) return true;
34736 return false;
34737 }
34738
34739 private boolean jj_3R_258() {
34740 Token xsp;
34741 xsp = jj_scanpos;
34742 if (jj_3_69()) {
34743 jj_scanpos = xsp;
34744 if (jj_3R_308()) {
34745 jj_scanpos = xsp;
34746 if (jj_3R_309()) return true;
34747 }
34748 }
34749 return false;
34750 }
34751
34752 private boolean jj_3R_365() {
34753 if (jj_3R_412()) return true;
34754 if (jj_scan_token(4)) return true;
34755 return false;
34756 }
34757
34758 private boolean jj_3_42() {
34759 Token xsp;
34760 xsp = jj_scanpos;
34761 if (jj_3R_129()) {
34762 jj_scanpos = xsp;
34763 if (jj_scan_token(297)) {
34764 jj_scanpos = xsp;
34765 if (jj_scan_token(144)) {
34766 jj_scanpos = xsp;
34767 if (jj_scan_token(93)) {
34768 jj_scanpos = xsp;
34769 if (jj_scan_token(76)) {
34770 jj_scanpos = xsp;
34771 if (jj_scan_token(241)) {
34772 jj_scanpos = xsp;
34773 if (jj_scan_token(248)) {
34774 jj_scanpos = xsp;
34775 if (jj_scan_token(111)) {
34776 jj_scanpos = xsp;
34777 if (jj_3R_130()) {
34778 jj_scanpos = xsp;
34779 if (jj_3R_131()) {
34780 jj_scanpos = xsp;
34781 if (jj_scan_token(165)) {
34782 jj_scanpos = xsp;
34783 if (jj_scan_token(318)) return true;
34784 }
34785 }
34786 }
34787 }
34788 }
34789 }
34790 }
34791 }
34792 }
34793 }
34794 }
34795 return false;
34796 }
34797
34798 private boolean jj_3R_129() {
34799 Token xsp;
34800 xsp = jj_scanpos;
34801 if (jj_scan_token(5)) jj_scanpos = xsp;
34802 if (jj_scan_token(SELECT)) return true;
34803 return false;
34804 }
34805
34806 private boolean jj_3R_364() {
34807 if (jj_3R_411()) return true;
34808 if (jj_scan_token(4)) return true;
34809 return false;
34810 }
34811
34812 private boolean jj_3R_363() {
34813 if (jj_3R_410()) return true;
34814 if (jj_scan_token(4)) return true;
34815 return false;
34816 }
34817
34818 private boolean jj_3R_165() {
34819 if (jj_scan_token(5)) return true;
34820 Token xsp;
34821 while (true) {
34822 xsp = jj_scanpos;
34823 if (jj_3R_258()) { jj_scanpos = xsp; break; }
34824 }
34825 while (true) {
34826 xsp = jj_scanpos;
34827 if (jj_3R_259()) { jj_scanpos = xsp; break; }
34828 }
34829 if (jj_scan_token(7)) return true;
34830 return false;
34831 }
34832
34833 private boolean jj_3R_362() {
34834 if (jj_3R_409()) return true;
34835 if (jj_scan_token(4)) return true;
34836 return false;
34837 }
34838
34839 private boolean jj_3R_361() {
34840 if (jj_3R_408()) return true;
34841 if (jj_scan_token(4)) return true;
34842 return false;
34843 }
34844
34845 private boolean jj_3R_360() {
34846 if (jj_3R_407()) return true;
34847 if (jj_scan_token(4)) return true;
34848 return false;
34849 }
34850
34851 private boolean jj_3R_359() {
34852 if (jj_3R_406()) return true;
34853 if (jj_scan_token(4)) return true;
34854 return false;
34855 }
34856
34857 private boolean jj_3_43() {
34858 if (jj_3R_132()) return true;
34859 if (jj_scan_token(4)) return true;
34860 return false;
34861 }
34862
34863 private boolean jj_3R_358() {
34864 if (jj_3R_405()) return true;
34865 Token xsp;
34866 xsp = jj_scanpos;
34867 if (jj_scan_token(4)) jj_scanpos = xsp;
34868 return false;
34869 }
34870
34871 private boolean jj_3R_442() {
34872 if (jj_scan_token(SET)) return true;
34873 if (jj_scan_token(TRANSACTION)) return true;
34874 return false;
34875 }
34876
34877 private boolean jj_3R_604() {
34878 if (jj_3R_124()) return true;
34879 return false;
34880 }
34881
34882 private boolean jj_3R_317() {
34883 Token xsp;
34884 xsp = jj_scanpos;
34885 if (jj_3R_358()) {
34886 jj_scanpos = xsp;
34887 if (jj_3_43()) {
34888 jj_scanpos = xsp;
34889 if (jj_3R_359()) {
34890 jj_scanpos = xsp;
34891 if (jj_3R_360()) {
34892 jj_scanpos = xsp;
34893 if (jj_3R_361()) {
34894 jj_scanpos = xsp;
34895 if (jj_3R_362()) {
34896 jj_scanpos = xsp;
34897 if (jj_3R_363()) {
34898 jj_scanpos = xsp;
34899 if (jj_3R_364()) {
34900 jj_scanpos = xsp;
34901 if (jj_3R_365()) {
34902 jj_scanpos = xsp;
34903 if (jj_3R_366()) {
34904 jj_scanpos = xsp;
34905 if (jj_3R_367()) {
34906 jj_scanpos = xsp;
34907 if (jj_3R_368()) {
34908 jj_scanpos = xsp;
34909 if (jj_3R_369()) {
34910 jj_scanpos = xsp;
34911 if (jj_3R_370()) {
34912 jj_scanpos = xsp;
34913 if (jj_3R_371()) {
34914 jj_scanpos = xsp;
34915 if (jj_3R_372()) {
34916 jj_scanpos = xsp;
34917 if (jj_3R_373()) {
34918 jj_scanpos = xsp;
34919 if (jj_3R_374()) {
34920 jj_scanpos = xsp;
34921 if (jj_3R_375()) {
34922 jj_scanpos = xsp;
34923 if (jj_3R_376()) {
34924 jj_scanpos = xsp;
34925 if (jj_3R_377()) return true;
34926 }
34927 }
34928 }
34929 }
34930 }
34931 }
34932 }
34933 }
34934 }
34935 }
34936 }
34937 }
34938 }
34939 }
34940 }
34941 }
34942 }
34943 }
34944 }
34945 }
34946 return false;
34947 }
34948
34949 private boolean jj_3R_164() {
34950 if (jj_3R_249()) return true;
34951 return false;
34952 }
34953
34954 private boolean jj_3_67() {
34955 Token xsp;
34956 xsp = jj_scanpos;
34957 if (jj_scan_token(152)) {
34958 jj_scanpos = xsp;
34959 if (jj_scan_token(51)) return true;
34960 }
34961 if (jj_3R_146()) return true;
34962 if (jj_scan_token(OF)) return true;
34963 if (jj_3R_236()) return true;
34964 return false;
34965 }
34966
34967 private boolean jj_3R_145() {
34968 if (jj_3R_239()) return true;
34969 return false;
34970 }
34971
34972 private boolean jj_3_66() {
34973 Token xsp;
34974 xsp = jj_scanpos;
34975 if (jj_scan_token(152)) {
34976 jj_scanpos = xsp;
34977 if (jj_scan_token(51)) return true;
34978 }
34979 if (jj_scan_token(OPAQUE)) return true;
34980 if (jj_scan_token(VARYING)) return true;
34981 if (jj_scan_token(24)) return true;
34982 return false;
34983 }
34984
34985 private boolean jj_3_68() {
34986 if (jj_scan_token(EXTERNAL)) return true;
34987 if (jj_scan_token(IDENTIFIER)) return true;
34988 if (jj_scan_token(IDENTIFIER)) return true;
34989 if (jj_scan_token(LANGUAGE)) return true;
34990 if (jj_scan_token(JAVA)) return true;
34991 if (jj_scan_token(USING)) return true;
34992 if (jj_scan_token(IDENTIFIER)) return true;
34993 return false;
34994 }
34995
34996 private boolean jj_3_65() {
34997 Token xsp;
34998 xsp = jj_scanpos;
34999 if (jj_scan_token(152)) {
35000 jj_scanpos = xsp;
35001 if (jj_scan_token(51)) return true;
35002 }
35003 if (jj_scan_token(OBJECT)) return true;
35004 return false;
35005 }
35006
35007 private boolean jj_3R_144() {
35008 if (jj_scan_token(AUTHID)) return true;
35009 Token xsp;
35010 xsp = jj_scanpos;
35011 if (jj_scan_token(37)) {
35012 jj_scanpos = xsp;
35013 if (jj_scan_token(36)) return true;
35014 }
35015 return false;
35016 }
35017
35018 private boolean jj_3R_257() {
35019 if (jj_scan_token(UNDER)) return true;
35020 if (jj_3R_155()) return true;
35021 return false;
35022 }
35023
35024 private boolean jj_3R_163() {
35025 Token xsp;
35026 xsp = jj_scanpos;
35027 if (jj_3R_257()) {
35028 jj_scanpos = xsp;
35029 if (jj_3_65()) {
35030 jj_scanpos = xsp;
35031 if (jj_3_66()) {
35032 jj_scanpos = xsp;
35033 if (jj_3_67()) return true;
35034 }
35035 }
35036 }
35037 return false;
35038 }
35039
35040 private boolean jj_3R_256() {
35041 Token xsp;
35042 xsp = jj_scanpos;
35043 if (jj_scan_token(100)) {
35044 jj_scanpos = xsp;
35045 if (jj_scan_token(182)) return true;
35046 }
35047 return false;
35048 }
35049
35050 private boolean jj_3R_249() {
35051 if (jj_scan_token(WRAPPED)) return true;
35052 return false;
35053 }
35054
35055 private boolean jj_3R_603() {
35056 if (jj_3R_351()) return true;
35057 return false;
35058 }
35059
35060 private boolean jj_3_64() {
35061 Token xsp;
35062 xsp = jj_scanpos;
35063 if (jj_3R_144()) {
35064 jj_scanpos = xsp;
35065 if (jj_3R_145()) return true;
35066 }
35067 return false;
35068 }
35069
35070 private boolean jj_3_63() {
35071 if (jj_scan_token(OID)) return true;
35072 if (jj_scan_token(STRING_LITERAL)) return true;
35073 return false;
35074 }
35075
35076 private boolean jj_3R_255() {
35077 if (jj_scan_token(OR)) return true;
35078 if (jj_scan_token(REPLACE)) return true;
35079 return false;
35080 }
35081
35082 private boolean jj_3R_602() {
35083 if (jj_3R_174()) return true;
35084 return false;
35085 }
35086
35087 private boolean jj_3R_162() {
35088 if (jj_scan_token(CREATE)) return true;
35089 Token xsp;
35090 xsp = jj_scanpos;
35091 if (jj_3R_255()) jj_scanpos = xsp;
35092 xsp = jj_scanpos;
35093 if (jj_3R_256()) jj_scanpos = xsp;
35094 return false;
35095 }
35096
35097 private boolean jj_3R_105() {
35098 Token xsp;
35099 xsp = jj_scanpos;
35100 if (jj_3R_162()) jj_scanpos = xsp;
35101 if (jj_scan_token(TYPE)) return true;
35102 if (jj_3R_155()) return true;
35103 xsp = jj_scanpos;
35104 if (jj_scan_token(123)) jj_scanpos = xsp;
35105 xsp = jj_scanpos;
35106 if (jj_3_63()) jj_scanpos = xsp;
35107 while (true) {
35108 xsp = jj_scanpos;
35109 if (jj_3_64()) { jj_scanpos = xsp; break; }
35110 }
35111 xsp = jj_scanpos;
35112 if (jj_3R_163()) jj_scanpos = xsp;
35113 xsp = jj_scanpos;
35114 if (jj_3_68()) jj_scanpos = xsp;
35115 xsp = jj_scanpos;
35116 if (jj_3R_164()) jj_scanpos = xsp;
35117 xsp = jj_scanpos;
35118 if (jj_3R_165()) jj_scanpos = xsp;
35119 while (true) {
35120 xsp = jj_scanpos;
35121 if (jj_3R_166()) { jj_scanpos = xsp; break; }
35122 }
35123 while (true) {
35124 xsp = jj_scanpos;
35125 if (jj_3R_167()) { jj_scanpos = xsp; break; }
35126 }
35127 xsp = jj_scanpos;
35128 if (jj_3R_168()) jj_scanpos = xsp;
35129 return false;
35130 }
35131
35132 private boolean jj_3R_568() {
35133 if (jj_3R_192()) return true;
35134 if (jj_scan_token(BEGIN)) return true;
35135 Token xsp;
35136 while (true) {
35137 xsp = jj_scanpos;
35138 if (jj_3R_602()) { jj_scanpos = xsp; break; }
35139 }
35140 xsp = jj_scanpos;
35141 if (jj_3R_603()) jj_scanpos = xsp;
35142 if (jj_scan_token(END)) return true;
35143 xsp = jj_scanpos;
35144 if (jj_3R_604()) jj_scanpos = xsp;
35145 if (jj_scan_token(4)) return true;
35146 return false;
35147 }
35148
35149 private boolean jj_3R_567() {
35150 if (jj_3R_123()) return true;
35151 Token xsp;
35152 xsp = jj_scanpos;
35153 if (jj_scan_token(4)) jj_scanpos = xsp;
35154 return false;
35155 }
35156
35157 private boolean jj_3R_531() {
35158 Token xsp;
35159 xsp = jj_scanpos;
35160 if (jj_scan_token(152)) {
35161 jj_scanpos = xsp;
35162 if (jj_scan_token(51)) return true;
35163 }
35164 xsp = jj_scanpos;
35165 if (jj_3R_567()) {
35166 jj_scanpos = xsp;
35167 if (jj_3R_568()) return true;
35168 }
35169 return false;
35170 }
35171
35172 private boolean jj_3R_405() {
35173 Token xsp;
35174 xsp = jj_scanpos;
35175 if (jj_scan_token(250)) {
35176 jj_scanpos = xsp;
35177 if (jj_scan_token(297)) {
35178 jj_scanpos = xsp;
35179 if (jj_scan_token(144)) {
35180 jj_scanpos = xsp;
35181 if (jj_scan_token(93)) {
35182 jj_scanpos = xsp;
35183 if (jj_scan_token(76)) {
35184 jj_scanpos = xsp;
35185 if (jj_scan_token(241)) {
35186 jj_scanpos = xsp;
35187 if (jj_scan_token(248)) {
35188 jj_scanpos = xsp;
35189 if (jj_scan_token(111)) {
35190 jj_scanpos = xsp;
35191 if (jj_3R_442()) {
35192 jj_scanpos = xsp;
35193 if (jj_3R_443()) {
35194 jj_scanpos = xsp;
35195 if (jj_scan_token(165)) {
35196 jj_scanpos = xsp;
35197 if (jj_scan_token(318)) return true;
35198 }
35199 }
35200 }
35201 }
35202 }
35203 }
35204 }
35205 }
35206 }
35207 }
35208 }
35209 if (jj_3R_180()) return true;
35210 return false;
35211 }
35212
35213 private boolean jj_3_61() {
35214 if (jj_3R_124()) return true;
35215 if (jj_scan_token(3)) return true;
35216 return false;
35217 }
35218
35219 private boolean jj_3R_491() {
35220 return false;
35221 }
35222
35223 private boolean jj_3R_242() {
35224 Token xsp;
35225 xsp = jj_scanpos;
35226 if (jj_scan_token(162)) {
35227 jj_scanpos = xsp;
35228 if (jj_scan_token(204)) return true;
35229 }
35230 return false;
35231 }
35232
35233 private boolean jj_3R_241() {
35234 Token xsp;
35235 xsp = jj_scanpos;
35236 if (jj_scan_token(183)) jj_scanpos = xsp;
35237 xsp = jj_scanpos;
35238 if (jj_scan_token(208)) {
35239 jj_scanpos = xsp;
35240 if (jj_scan_token(145)) {
35241 jj_scanpos = xsp;
35242 if (jj_scan_token(119)) return true;
35243 }
35244 }
35245 return false;
35246 }
35247
35248 private boolean jj_3_62() {
35249 if (jj_3R_124()) return true;
35250 if (jj_scan_token(3)) return true;
35251 if (jj_3R_124()) return true;
35252 if (jj_scan_token(3)) return true;
35253 if (jj_3R_124()) return true;
35254 return false;
35255 }
35256
35257 private boolean jj_3R_147() {
35258 Token xsp;
35259 while (true) {
35260 xsp = jj_scanpos;
35261 if (jj_3R_241()) { jj_scanpos = xsp; break; }
35262 }
35263 xsp = jj_scanpos;
35264 if (jj_3R_242()) jj_scanpos = xsp;
35265 xsp = jj_scanpos;
35266 if (jj_scan_token(80)) {
35267 jj_scanpos = xsp;
35268 if (jj_scan_token(164)) {
35269 jj_scanpos = xsp;
35270 if (jj_scan_token(262)) return true;
35271 }
35272 }
35273 if (jj_3R_194()) return true;
35274 xsp = jj_scanpos;
35275 if (jj_scan_token(95)) jj_scanpos = xsp;
35276 xsp = jj_scanpos;
35277 if (jj_scan_token(210)) jj_scanpos = xsp;
35278 xsp = jj_scanpos;
35279 if (jj_scan_token(214)) jj_scanpos = xsp;
35280 xsp = jj_scanpos;
35281 if (jj_scan_token(236)) jj_scanpos = xsp;
35282 xsp = jj_scanpos;
35283 if (jj_3R_531()) jj_scanpos = xsp;
35284 return false;
35285 }
35286
35287 private boolean jj_3R_188() {
35288 return false;
35289 }
35290
35291 private boolean jj_3R_262() {
35292 if (jj_3R_124()) return true;
35293 return false;
35294 }
35295
35296 private boolean jj_3R_190() {
35297 return false;
35298 }
35299
35300 private boolean jj_3R_185() {
35301 if (jj_3R_143()) return true;
35302 if (jj_scan_token(IDENTIFIED)) return true;
35303 return false;
35304 }
35305
35306 private boolean jj_3R_184() {
35307 if (jj_scan_token(CONNECT)) return true;
35308 if (jj_scan_token(TO)) return true;
35309 return false;
35310 }
35311
35312 private boolean jj_3R_112() {
35313 if (jj_scan_token(CREATE)) return true;
35314 Token xsp;
35315 xsp = jj_scanpos;
35316 if (jj_scan_token(410)) jj_scanpos = xsp;
35317 xsp = jj_scanpos;
35318 if (jj_scan_token(224)) jj_scanpos = xsp;
35319 if (jj_scan_token(DATABASE)) return true;
35320 if (jj_scan_token(LINK)) return true;
35321 if (jj_3R_155()) return true;
35322 xsp = jj_scanpos;
35323 if (jj_3R_184()) {
35324 jj_scanpos = xsp;
35325 if (jj_3R_185()) return true;
35326 }
35327 return false;
35328 }
35329
35330 private boolean jj_3R_459() {
35331 if (jj_3R_174()) return true;
35332 return false;
35333 }
35334
35335 private boolean jj_3R_182() {
35336 if (jj_scan_token(OR)) return true;
35337 if (jj_scan_token(REPLACE)) return true;
35338 return false;
35339 }
35340
35341 private boolean jj_3R_111() {
35342 if (jj_scan_token(CREATE)) return true;
35343 Token xsp;
35344 xsp = jj_scanpos;
35345 if (jj_3R_182()) jj_scanpos = xsp;
35346 if (jj_scan_token(DIRECTORY)) return true;
35347 if (jj_3R_155()) return true;
35348 if (jj_scan_token(AS)) return true;
35349 if (jj_3R_183()) return true;
35350 xsp = jj_scanpos;
35351 if (jj_scan_token(4)) {
35352 jj_scanpos = xsp;
35353 if (jj_scan_token(1)) return true;
35354 }
35355 return false;
35356 }
35357
35358 private boolean jj_3R_181() {
35359 if (jj_scan_token(OR)) return true;
35360 if (jj_scan_token(REPLACE)) return true;
35361 return false;
35362 }
35363
35364 private boolean jj_3R_564() {
35365 return false;
35366 }
35367
35368 private boolean jj_3R_263() {
35369 if (jj_scan_token(6)) return true;
35370 return false;
35371 }
35372
35373 private boolean jj_3R_110() {
35374 if (jj_scan_token(CREATE)) return true;
35375 Token xsp;
35376 xsp = jj_scanpos;
35377 if (jj_3R_181()) jj_scanpos = xsp;
35378 xsp = jj_scanpos;
35379 if (jj_scan_token(224)) jj_scanpos = xsp;
35380 if (jj_scan_token(SYNONYM)) return true;
35381 if (jj_3R_155()) return true;
35382 if (jj_scan_token(FOR)) return true;
35383 if (jj_3R_155()) return true;
35384 xsp = jj_scanpos;
35385 if (jj_scan_token(4)) {
35386 jj_scanpos = xsp;
35387 if (jj_scan_token(1)) return true;
35388 }
35389 return false;
35390 }
35391
35392 private boolean jj_3R_458() {
35393 if (jj_scan_token(OR)) return true;
35394 if (jj_3R_128()) return true;
35395 return false;
35396 }
35397
35398 private boolean jj_3R_171() {
35399 if (jj_scan_token(OR)) return true;
35400 if (jj_scan_token(REPLACE)) return true;
35401 return false;
35402 }
35403
35404 private boolean jj_3R_173() {
35405 if (jj_scan_token(5)) return true;
35406 if (jj_3R_262()) return true;
35407 Token xsp;
35408 while (true) {
35409 xsp = jj_scanpos;
35410 if (jj_3R_263()) { jj_scanpos = xsp; break; }
35411 }
35412 if (jj_scan_token(7)) return true;
35413 return false;
35414 }
35415
35416 private boolean jj_3R_460() {
35417 if (jj_3R_174()) return true;
35418 return false;
35419 }
35420
35421 private boolean jj_3R_172() {
35422 Token xsp;
35423 xsp = jj_scanpos;
35424 if (jj_scan_token(179)) jj_scanpos = xsp;
35425 if (jj_scan_token(FORCE)) return true;
35426 return false;
35427 }
35428
35429 private boolean jj_3R_107() {
35430 if (jj_scan_token(CREATE)) return true;
35431 Token xsp;
35432 xsp = jj_scanpos;
35433 if (jj_3R_171()) jj_scanpos = xsp;
35434 xsp = jj_scanpos;
35435 if (jj_3R_172()) jj_scanpos = xsp;
35436 if (jj_scan_token(VIEW)) return true;
35437 if (jj_3R_155()) return true;
35438 xsp = jj_scanpos;
35439 if (jj_3R_173()) jj_scanpos = xsp;
35440 if (jj_scan_token(AS)) return true;
35441 if (jj_3R_174()) return true;
35442 xsp = jj_scanpos;
35443 if (jj_scan_token(4)) {
35444 jj_scanpos = xsp;
35445 if (jj_scan_token(1)) return true;
35446 }
35447 return false;
35448 }
35449
35450 private boolean jj_3R_180() {
35451 return false;
35452 }
35453
35454 private boolean jj_3R_170() {
35455 if (jj_3R_124()) return true;
35456 if (jj_3R_236()) return true;
35457 return false;
35458 }
35459
35460 private boolean jj_3R_629() {
35461 if (jj_scan_token(6)) return true;
35462 if (jj_3R_124()) return true;
35463 return false;
35464 }
35465
35466 private boolean jj_3R_628() {
35467 if (jj_scan_token(6)) return true;
35468 if (jj_3R_124()) return true;
35469 return false;
35470 }
35471
35472 private boolean jj_3R_169() {
35473 if (jj_scan_token(GLOBAL)) return true;
35474 if (jj_scan_token(TEMPORARY)) return true;
35475 return false;
35476 }
35477
35478 private boolean jj_3R_401() {
35479 if (jj_scan_token(WHEN)) return true;
35480 if (jj_scan_token(OTHERS)) return true;
35481 if (jj_scan_token(THEN)) return true;
35482 Token xsp;
35483 if (jj_3R_460()) return true;
35484 while (true) {
35485 xsp = jj_scanpos;
35486 if (jj_3R_460()) { jj_scanpos = xsp; break; }
35487 }
35488 return false;
35489 }
35490
35491 private boolean jj_3_41() {
35492 if (jj_scan_token(WHEN)) return true;
35493 if (jj_3R_128()) return true;
35494 Token xsp;
35495 while (true) {
35496 xsp = jj_scanpos;
35497 if (jj_3R_458()) { jj_scanpos = xsp; break; }
35498 }
35499 if (jj_scan_token(THEN)) return true;
35500 if (jj_3R_459()) return true;
35501 while (true) {
35502 xsp = jj_scanpos;
35503 if (jj_3R_459()) { jj_scanpos = xsp; break; }
35504 }
35505 return false;
35506 }
35507
35508 private boolean jj_3_60() {
35509 if (jj_scan_token(ON)) return true;
35510 if (jj_scan_token(COMMIT)) return true;
35511 return false;
35512 }
35513
35514 private boolean jj_3R_106() {
35515 if (jj_scan_token(CREATE)) return true;
35516 Token xsp;
35517 xsp = jj_scanpos;
35518 if (jj_3R_169()) jj_scanpos = xsp;
35519 if (jj_scan_token(TABLE)) return true;
35520 if (jj_3R_155()) return true;
35521 if (jj_scan_token(5)) return true;
35522 if (jj_3R_170()) return true;
35523 return false;
35524 }
35525
35526 private boolean jj_3R_351() {
35527 if (jj_scan_token(EXCEPTION)) return true;
35528 Token xsp;
35529 while (true) {
35530 xsp = jj_scanpos;
35531 if (jj_3_41()) { jj_scanpos = xsp; break; }
35532 }
35533 xsp = jj_scanpos;
35534 if (jj_3R_401()) jj_scanpos = xsp;
35535 return false;
35536 }
35537
35538 private boolean jj_3R_621() {
35539 Token xsp;
35540 xsp = jj_scanpos;
35541 if (jj_scan_token(125)) {
35542 jj_scanpos = xsp;
35543 if (jj_scan_token(223)) {
35544 jj_scanpos = xsp;
35545 if (jj_scan_token(209)) {
35546 jj_scanpos = xsp;
35547 if (jj_scan_token(282)) {
35548 jj_scanpos = xsp;
35549 if (jj_scan_token(284)) return true;
35550 }
35551 }
35552 }
35553 }
35554 return false;
35555 }
35556
35557 private boolean jj_3R_349() {
35558 Token xsp;
35559 xsp = jj_scanpos;
35560 if (jj_scan_token(125)) {
35561 jj_scanpos = xsp;
35562 if (jj_scan_token(223)) {
35563 jj_scanpos = xsp;
35564 if (jj_scan_token(209)) {
35565 jj_scanpos = xsp;
35566 if (jj_scan_token(282)) {
35567 jj_scanpos = xsp;
35568 if (jj_scan_token(284)) return true;
35569 }
35570 }
35571 }
35572 }
35573 return false;
35574 }
35575
35576 private boolean jj_3R_350() {
35577 if (jj_scan_token(6)) return true;
35578 Token xsp;
35579 xsp = jj_scanpos;
35580 if (jj_3R_621()) jj_scanpos = xsp;
35581 if (jj_3R_128()) return true;
35582 return false;
35583 }
35584
35585 private boolean jj_3R_490() {
35586 if (jj_scan_token(6)) return true;
35587 if (jj_3R_127()) return true;
35588 return false;
35589 }
35590
35591 private boolean jj_3R_489() {
35592 Token xsp;
35593 xsp = jj_scanpos;
35594 if (jj_scan_token(16)) {
35595 jj_scanpos = xsp;
35596 if (jj_scan_token(17)) return true;
35597 }
35598 return false;
35599 }
35600
35601 private boolean jj_3_40() {
35602 if (jj_scan_token(5)) return true;
35603 if (jj_3R_127()) return true;
35604 if (jj_scan_token(7)) return true;
35605 return false;
35606 }
35607
35608 private boolean jj_3R_239() {
35609 if (jj_scan_token(ACCESSIBLE)) return true;
35610 if (jj_scan_token(BY)) return true;
35611 if (jj_scan_token(5)) return true;
35612 Token xsp;
35613 xsp = jj_scanpos;
35614 if (jj_3R_349()) jj_scanpos = xsp;
35615 if (jj_3R_128()) return true;
35616 while (true) {
35617 xsp = jj_scanpos;
35618 if (jj_3R_350()) { jj_scanpos = xsp; break; }
35619 }
35620 if (jj_scan_token(7)) return true;
35621 return false;
35622 }
35623
35624 private boolean jj_3R_622() {
35625 Token xsp;
35626 xsp = jj_scanpos;
35627 if (jj_scan_token(130)) {
35628 jj_scanpos = xsp;
35629 if (jj_scan_token(226)) return true;
35630 }
35631 if (jj_scan_token(5)) return true;
35632 if (jj_3R_124()) return true;
35633 while (true) {
35634 xsp = jj_scanpos;
35635 if (jj_3R_628()) { jj_scanpos = xsp; break; }
35636 }
35637 if (jj_scan_token(7)) return true;
35638 return false;
35639 }
35640
35641 private boolean jj_3R_623() {
35642 Token xsp;
35643 xsp = jj_scanpos;
35644 if (jj_scan_token(204)) {
35645 jj_scanpos = xsp;
35646 if (jj_scan_token(71)) return true;
35647 }
35648 if (jj_scan_token(BY)) return true;
35649 if (jj_scan_token(5)) return true;
35650 if (jj_3R_124()) return true;
35651 while (true) {
35652 xsp = jj_scanpos;
35653 if (jj_3R_629()) { jj_scanpos = xsp; break; }
35654 }
35655 if (jj_scan_token(7)) return true;
35656 return false;
35657 }
35658
35659 private boolean jj_3R_481() {
35660 if (jj_scan_token(TO)) return true;
35661 Token xsp;
35662 xsp = jj_scanpos;
35663 if (jj_scan_token(316)) {
35664 jj_scanpos = xsp;
35665 if (jj_scan_token(173)) {
35666 jj_scanpos = xsp;
35667 if (jj_scan_token(89)) {
35668 jj_scanpos = xsp;
35669 if (jj_scan_token(133)) {
35670 jj_scanpos = xsp;
35671 if (jj_scan_token(168)) {
35672 jj_scanpos = xsp;
35673 if (jj_scan_token(249)) return true;
35674 }
35675 }
35676 }
35677 }
35678 }
35679 xsp = jj_scanpos;
35680 if (jj_3_40()) jj_scanpos = xsp;
35681 return false;
35682 }
35683
35684 private boolean jj_3R_507() {
35685 if (jj_scan_token(LOCAL)) return true;
35686 return false;
35687 }
35688
35689 private boolean jj_3R_480() {
35690 if (jj_scan_token(WITH)) return true;
35691 Token xsp;
35692 xsp = jj_scanpos;
35693 if (jj_3R_507()) jj_scanpos = xsp;
35694 if (jj_scan_token(TIME)) return true;
35695 if (jj_scan_token(ZONE)) return true;
35696 return false;
35697 }
35698
35699 private boolean jj_3R_435() {
35700 Token xsp;
35701 xsp = jj_scanpos;
35702 if (jj_3R_480()) {
35703 jj_scanpos = xsp;
35704 if (jj_3R_481()) return true;
35705 }
35706 return false;
35707 }
35708
35709 private boolean jj_3R_429() {
35710 if (jj_scan_token(5)) return true;
35711 if (jj_scan_token(PARTITION)) return true;
35712 if (jj_3R_124()) return true;
35713 if (jj_scan_token(BY)) return true;
35714 Token xsp;
35715 xsp = jj_scanpos;
35716 if (jj_scan_token(49)) {
35717 jj_scanpos = xsp;
35718 if (jj_3R_622()) return true;
35719 }
35720 if (jj_scan_token(7)) return true;
35721 xsp = jj_scanpos;
35722 if (jj_3R_623()) jj_scanpos = xsp;
35723 return false;
35724 }
35725
35726 private boolean jj_3_39() {
35727 if (jj_scan_token(5)) return true;
35728 if (jj_3R_127()) return true;
35729 if (jj_scan_token(7)) return true;
35730 return false;
35731 }
35732
35733 private boolean jj_3R_119() {
35734 if (jj_3R_124()) return true;
35735 if (jj_scan_token(EXCEPTION)) return true;
35736 if (jj_scan_token(4)) return true;
35737 return false;
35738 }
35739
35740 private boolean jj_3R_519() {
35741 if (jj_3R_183()) return true;
35742 return false;
35743 }
35744
35745 private boolean jj_3R_422() {
35746 if (jj_scan_token(PRAGMA)) return true;
35747 if (jj_scan_token(INLINE)) return true;
35748 if (jj_scan_token(5)) return true;
35749 if (jj_3R_128()) return true;
35750 if (jj_scan_token(6)) return true;
35751 if (jj_3R_183()) return true;
35752 if (jj_scan_token(7)) return true;
35753 return false;
35754 }
35755
35756 private boolean jj_3R_518() {
35757 if (jj_3R_124()) return true;
35758 return false;
35759 }
35760
35761 private boolean jj_3R_469() {
35762 if (jj_3R_128()) return true;
35763 if (jj_scan_token(5)) return true;
35764 if (jj_3R_491()) return true;
35765 return false;
35766 }
35767
35768 private boolean jj_3R_434() {
35769 Token xsp;
35770 xsp = jj_scanpos;
35771 if (jj_scan_token(316)) {
35772 jj_scanpos = xsp;
35773 if (jj_scan_token(173)) {
35774 jj_scanpos = xsp;
35775 if (jj_scan_token(89)) {
35776 jj_scanpos = xsp;
35777 if (jj_scan_token(133)) {
35778 jj_scanpos = xsp;
35779 if (jj_scan_token(168)) {
35780 jj_scanpos = xsp;
35781 if (jj_scan_token(249)) return true;
35782 }
35783 }
35784 }
35785 }
35786 }
35787 return false;
35788 }
35789
35790 private boolean jj_3R_468() {
35791 if (jj_scan_token(INTERFACE)) return true;
35792 if (jj_scan_token(5)) return true;
35793 if (jj_scan_token(IDENTIFIER)) return true;
35794 if (jj_scan_token(6)) return true;
35795 if (jj_3R_124()) return true;
35796 Token xsp;
35797 xsp = jj_scanpos;
35798 if (jj_3R_490()) jj_scanpos = xsp;
35799 if (jj_scan_token(7)) return true;
35800 return false;
35801 }
35802
35803 private boolean jj_3R_433() {
35804 if (jj_3R_183()) return true;
35805 return false;
35806 }
35807
35808 private boolean jj_3R_467() {
35809 if (jj_scan_token(EXCEPTION_INIT)) return true;
35810 if (jj_scan_token(5)) return true;
35811 if (jj_scan_token(IDENTIFIER)) return true;
35812 if (jj_scan_token(6)) return true;
35813 Token xsp;
35814 xsp = jj_scanpos;
35815 if (jj_3R_489()) jj_scanpos = xsp;
35816 if (jj_3R_127()) return true;
35817 if (jj_scan_token(7)) return true;
35818 return false;
35819 }
35820
35821 private boolean jj_3R_488() {
35822 if (jj_scan_token(6)) return true;
35823 Token xsp;
35824 xsp = jj_scanpos;
35825 if (jj_3R_518()) {
35826 jj_scanpos = xsp;
35827 if (jj_3R_519()) return true;
35828 }
35829 return false;
35830 }
35831
35832 private boolean jj_3R_432() {
35833 if (jj_scan_token(CHARACTER_LITERAL)) return true;
35834 return false;
35835 }
35836
35837 private boolean jj_3R_466() {
35838 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35839 if (jj_scan_token(5)) return true;
35840 if (jj_3R_124()) return true;
35841 Token xsp;
35842 if (jj_3R_488()) return true;
35843 while (true) {
35844 xsp = jj_scanpos;
35845 if (jj_3R_488()) { jj_scanpos = xsp; break; }
35846 }
35847 if (jj_scan_token(7)) return true;
35848 return false;
35849 }
35850
35851 private boolean jj_3R_465() {
35852 if (jj_scan_token(TIMESTAMP)) return true;
35853 if (jj_scan_token(5)) return true;
35854 if (jj_3R_183()) return true;
35855 if (jj_scan_token(7)) return true;
35856 return false;
35857 }
35858
35859 private boolean jj_3R_423() {
35860 if (jj_scan_token(PRAGMA)) return true;
35861 Token xsp;
35862 xsp = jj_scanpos;
35863 if (jj_scan_token(38)) {
35864 jj_scanpos = xsp;
35865 if (jj_scan_token(41)) {
35866 jj_scanpos = xsp;
35867 if (jj_3R_465()) {
35868 jj_scanpos = xsp;
35869 if (jj_3R_466()) {
35870 jj_scanpos = xsp;
35871 if (jj_3R_467()) {
35872 jj_scanpos = xsp;
35873 if (jj_3R_468()) {
35874 jj_scanpos = xsp;
35875 if (jj_3R_469()) return true;
35876 }
35877 }
35878 }
35879 }
35880 }
35881 }
35882 if (jj_scan_token(4)) return true;
35883 return false;
35884 }
35885
35886 private boolean jj_3_34() {
35887 if (jj_scan_token(5)) return true;
35888 if (jj_3R_127()) return true;
35889 if (jj_scan_token(7)) return true;
35890 return false;
35891 }
35892
35893 private boolean jj_3R_393() {
35894 Token xsp;
35895 xsp = jj_scanpos;
35896 if (jj_scan_token(149)) {
35897 jj_scanpos = xsp;
35898 if (jj_scan_token(275)) {
35899 jj_scanpos = xsp;
35900 if (jj_scan_token(88)) return true;
35901 }
35902 }
35903 xsp = jj_scanpos;
35904 if (jj_3R_432()) {
35905 jj_scanpos = xsp;
35906 if (jj_3R_433()) return true;
35907 }
35908 xsp = jj_scanpos;
35909 if (jj_3R_434()) jj_scanpos = xsp;
35910 xsp = jj_scanpos;
35911 if (jj_3_39()) jj_scanpos = xsp;
35912 xsp = jj_scanpos;
35913 if (jj_3R_435()) jj_scanpos = xsp;
35914 return false;
35915 }
35916
35917 private boolean jj_3R_121() {
35918 if (jj_3R_198()) return true;
35919 if (jj_scan_token(4)) return true;
35920 return false;
35921 }
35922
35923 private boolean jj_3_38() {
35924 if (jj_scan_token(TO)) return true;
35925 if (jj_scan_token(SECOND)) return true;
35926 Token xsp;
35927 xsp = jj_scanpos;
35928 if (jj_3_34()) jj_scanpos = xsp;
35929 return false;
35930 }
35931
35932 private boolean jj_3_37() {
35933 if (jj_scan_token(TO)) return true;
35934 if (jj_scan_token(MONTH)) return true;
35935 return false;
35936 }
35937
35938 private boolean jj_3_36() {
35939 if (jj_scan_token(WITH)) return true;
35940 if (jj_scan_token(TIME)) return true;
35941 if (jj_scan_token(ZONE)) return true;
35942 return false;
35943 }
35944
35945 private boolean jj_3_35() {
35946 if (jj_scan_token(WITH)) return true;
35947 if (jj_scan_token(LOCAL)) return true;
35948 if (jj_scan_token(TIME)) return true;
35949 if (jj_scan_token(ZONE)) return true;
35950 return false;
35951 }
35952
35953 private boolean jj_3R_569() {
35954 if (jj_scan_token(USING)) return true;
35955 Token xsp;
35956 xsp = jj_scanpos;
35957 if (jj_scan_token(401)) {
35958 jj_scanpos = xsp;
35959 if (jj_scan_token(402)) return true;
35960 }
35961 return false;
35962 }
35963
35964 private boolean jj_3R_207() {
35965 Token xsp;
35966 xsp = jj_scanpos;
35967 if (jj_3R_291()) {
35968 jj_scanpos = xsp;
35969 if (jj_3_35()) {
35970 jj_scanpos = xsp;
35971 if (jj_3_36()) {
35972 jj_scanpos = xsp;
35973 if (jj_3_37()) {
35974 jj_scanpos = xsp;
35975 if (jj_3_38()) return true;
35976 }
35977 }
35978 }
35979 }
35980 return false;
35981 }
35982
35983 private boolean jj_3R_291() {
35984 if (jj_scan_token(CHARACTER)) return true;
35985 if (jj_scan_token(SET)) return true;
35986 if (jj_3R_295()) return true;
35987 return false;
35988 }
35989
35990 private boolean jj_3_59() {
35991 if (jj_3R_143()) return true;
35992 Token xsp;
35993 xsp = jj_scanpos;
35994 if (jj_scan_token(23)) {
35995 jj_scanpos = xsp;
35996 if (jj_scan_token(51)) return true;
35997 }
35998 return false;
35999 }
36000
36001 private boolean jj_3R_436() {
36002 Token xsp;
36003 xsp = jj_scanpos;
36004 if (jj_3_59()) jj_scanpos = xsp;
36005 if (jj_3R_234()) return true;
36006 xsp = jj_scanpos;
36007 if (jj_3R_569()) jj_scanpos = xsp;
36008 return false;
36009 }
36010
36011 private boolean jj_3R_441() {
36012 if (jj_scan_token(BYTE)) return true;
36013 return false;
36014 }
36015
36016 private boolean jj_3R_440() {
36017 if (jj_scan_token(CHAR)) return true;
36018 return false;
36019 }
36020
36021 private boolean jj_3R_439() {
36022 if (jj_scan_token(6)) return true;
36023 if (jj_3R_484()) return true;
36024 return false;
36025 }
36026
36027 private boolean jj_3R_536() {
36028 if (jj_scan_token(6)) return true;
36029 if (jj_3R_436()) return true;
36030 return false;
36031 }
36032
36033 private boolean jj_3_33() {
36034 if (jj_scan_token(5)) return true;
36035 if (jj_3R_127()) return true;
36036 Token xsp;
36037 xsp = jj_scanpos;
36038 if (jj_3R_439()) jj_scanpos = xsp;
36039 xsp = jj_scanpos;
36040 if (jj_3R_440()) jj_scanpos = xsp;
36041 xsp = jj_scanpos;
36042 if (jj_3R_441()) jj_scanpos = xsp;
36043 if (jj_scan_token(7)) return true;
36044 return false;
36045 }
36046
36047 private boolean jj_3R_394() {
36048 if (jj_3R_436()) return true;
36049 Token xsp;
36050 while (true) {
36051 xsp = jj_scanpos;
36052 if (jj_3R_536()) { jj_scanpos = xsp; break; }
36053 }
36054 return false;
36055 }
36056
36057 private boolean jj_3R_206() {
36058 if (jj_scan_token(SELF)) return true;
36059 if (jj_scan_token(AS)) return true;
36060 if (jj_scan_token(RESULT)) return true;
36061 return false;
36062 }
36063
36064 private boolean jj_3R_203() {
36065 if (jj_scan_token(DOUBLE)) return true;
36066 if (jj_scan_token(PRECISION)) return true;
36067 return false;
36068 }
36069
36070 private boolean jj_3R_342() {
36071 if (jj_3R_394()) return true;
36072 return false;
36073 }
36074
36075 private boolean jj_3R_142() {
36076 if (jj_scan_token(11)) return true;
36077 return false;
36078 }
36079
36080 private boolean jj_3R_283() {
36081 Token xsp;
36082 xsp = jj_scanpos;
36083 if (jj_scan_token(117)) {
36084 jj_scanpos = xsp;
36085 if (jj_scan_token(283)) {
36086 jj_scanpos = xsp;
36087 if (jj_scan_token(296)) {
36088 jj_scanpos = xsp;
36089 if (jj_scan_token(377)) {
36090 jj_scanpos = xsp;
36091 if (jj_scan_token(44)) {
36092 jj_scanpos = xsp;
36093 if (jj_scan_token(321)) {
36094 jj_scanpos = xsp;
36095 if (jj_scan_token(45)) {
36096 jj_scanpos = xsp;
36097 if (jj_scan_token(344)) {
36098 jj_scanpos = xsp;
36099 if (jj_scan_token(345)) {
36100 jj_scanpos = xsp;
36101 if (jj_scan_token(53)) {
36102 jj_scanpos = xsp;
36103 if (jj_scan_token(389)) {
36104 jj_scanpos = xsp;
36105 if (jj_scan_token(54)) {
36106 jj_scanpos = xsp;
36107 if (jj_scan_token(346)) {
36108 jj_scanpos = xsp;
36109 if (jj_scan_token(408)) {
36110 jj_scanpos = xsp;
36111 if (jj_scan_token(55)) {
36112 jj_scanpos = xsp;
36113 if (jj_scan_token(322)) {
36114 jj_scanpos = xsp;
36115 if (jj_scan_token(312)) {
36116 jj_scanpos = xsp;
36117 if (jj_scan_token(313)) {
36118 jj_scanpos = xsp;
36119 if (jj_scan_token(395)) {
36120 jj_scanpos = xsp;
36121 if (jj_scan_token(62)) {
36122 jj_scanpos = xsp;
36123 if (jj_scan_token(64)) {
36124 jj_scanpos = xsp;
36125 if (jj_scan_token(349)) {
36126 jj_scanpos = xsp;
36127 if (jj_scan_token(65)) {
36128 jj_scanpos = xsp;
36129 if (jj_scan_token(390)) {
36130 jj_scanpos = xsp;
36131 if (jj_scan_token(401)) {
36132 jj_scanpos = xsp;
36133 if (jj_scan_token(320)) {
36134 jj_scanpos = xsp;
36135 if (jj_scan_token(376)) {
36136 jj_scanpos = xsp;
36137 if (jj_scan_token(375)) {
36138 jj_scanpos = xsp;
36139 if (jj_scan_token(314)) {
36140 jj_scanpos = xsp;
36141 if (jj_scan_token(70)) {
36142 jj_scanpos = xsp;
36143 if (jj_scan_token(72)) {
36144 jj_scanpos = xsp;
36145 if (jj_scan_token(73)) {
36146 jj_scanpos = xsp;
36147 if (jj_scan_token(74)) {
36148 jj_scanpos = xsp;
36149 if (jj_scan_token(75)) {
36150 jj_scanpos = xsp;
36151 if (jj_scan_token(76)) {
36152 jj_scanpos = xsp;
36153 if (jj_scan_token(347)) {
36154 jj_scanpos = xsp;
36155 if (jj_scan_token(80)) {
36156 jj_scanpos = xsp;
36157 if (jj_scan_token(370)) {
36158 jj_scanpos = xsp;
36159 if (jj_scan_token(81)) {
36160 jj_scanpos = xsp;
36161 if (jj_scan_token(82)) {
36162 jj_scanpos = xsp;
36163 if (jj_scan_token(379)) {
36164 jj_scanpos = xsp;
36165 if (jj_scan_token(84)) {
36166 jj_scanpos = xsp;
36167 if (jj_scan_token(37)) {
36168 jj_scanpos = xsp;
36169 if (jj_scan_token(86)) {
36170 jj_scanpos = xsp;
36171 if (jj_scan_token(87)) {
36172 jj_scanpos = xsp;
36173 if (jj_scan_token(348)) {
36174 jj_scanpos = xsp;
36175 if (jj_scan_token(89)) {
36176 jj_scanpos = xsp;
36177 if (jj_scan_token(406)) {
36178 jj_scanpos = xsp;
36179 if (jj_scan_token(350)) {
36180 jj_scanpos = xsp;
36181 if (jj_scan_token(301)) {
36182 jj_scanpos = xsp;
36183 if (jj_scan_token(380)) {
36184 jj_scanpos = xsp;
36185 if (jj_scan_token(36)) {
36186 jj_scanpos = xsp;
36187 if (jj_scan_token(411)) {
36188 jj_scanpos = xsp;
36189 if (jj_scan_token(96)) {
36190 jj_scanpos = xsp;
36191 if (jj_scan_token(351)) {
36192 jj_scanpos = xsp;
36193 if (jj_scan_token(381)) {
36194 jj_scanpos = xsp;
36195 if (jj_scan_token(300)) {
36196 jj_scanpos = xsp;
36197 if (jj_scan_token(352)) {
36198 jj_scanpos = xsp;
36199 if (jj_scan_token(101)) {
36200 jj_scanpos = xsp;
36201 if (jj_scan_token(396)) {
36202 jj_scanpos = xsp;
36203 if (jj_scan_token(104)) {
36204 jj_scanpos = xsp;
36205 if (jj_scan_token(106)) {
36206 jj_scanpos = xsp;
36207 if (jj_scan_token(107)) {
36208 jj_scanpos = xsp;
36209 if (jj_scan_token(109)) {
36210 jj_scanpos = xsp;
36211 if (jj_scan_token(113)) {
36212 jj_scanpos = xsp;
36213 if (jj_scan_token(115)) {
36214 jj_scanpos = xsp;
36215 if (jj_scan_token(114)) {
36216 jj_scanpos = xsp;
36217 if (jj_scan_token(116)) {
36218 jj_scanpos = xsp;
36219 if (jj_scan_token(119)) {
36220 jj_scanpos = xsp;
36221 if (jj_scan_token(353)) {
36222 jj_scanpos = xsp;
36223 if (jj_scan_token(123)) {
36224 jj_scanpos = xsp;
36225 if (jj_scan_token(125)) {
36226 jj_scanpos = xsp;
36227 if (jj_scan_token(126)) {
36228 jj_scanpos = xsp;
36229 if (jj_scan_token(130)) {
36230 jj_scanpos = xsp;
36231 if (jj_scan_token(132)) {
36232 jj_scanpos = xsp;
36233 if (jj_scan_token(382)) {
36234 jj_scanpos = xsp;
36235 if (jj_scan_token(133)) {
36236 jj_scanpos = xsp;
36237 if (jj_scan_token(136)) {
36238 jj_scanpos = xsp;
36239 if (jj_scan_token(142)) {
36240 jj_scanpos = xsp;
36241 if (jj_scan_token(143)) {
36242 jj_scanpos = xsp;
36243 if (jj_scan_token(140)) {
36244 jj_scanpos = xsp;
36245 if (jj_scan_token(145)) {
36246 jj_scanpos = xsp;
36247 if (jj_scan_token(149)) {
36248 jj_scanpos = xsp;
36249 if (jj_scan_token(151)) {
36250 jj_scanpos = xsp;
36251 if (jj_scan_token(153)) {
36252 jj_scanpos = xsp;
36253 if (jj_scan_token(154)) {
36254 jj_scanpos = xsp;
36255 if (jj_scan_token(42)) {
36256 jj_scanpos = xsp;
36257 if (jj_scan_token(399)) {
36258 jj_scanpos = xsp;
36259 if (jj_scan_token(393)) {
36260 jj_scanpos = xsp;
36261 if (jj_scan_token(372)) {
36262 jj_scanpos = xsp;
36263 if (jj_scan_token(155)) {
36264 jj_scanpos = xsp;
36265 if (jj_scan_token(367)) {
36266 jj_scanpos = xsp;
36267 if (jj_scan_token(157)) {
36268 jj_scanpos = xsp;
36269 if (jj_scan_token(409)) {
36270 jj_scanpos = xsp;
36271 if (jj_scan_token(317)) {
36272 jj_scanpos = xsp;
36273 if (jj_scan_token(354)) {
36274 jj_scanpos = xsp;
36275 if (jj_scan_token(355)) {
36276 jj_scanpos = xsp;
36277 if (jj_scan_token(162)) {
36278 jj_scanpos = xsp;
36279 if (jj_scan_token(163)) {
36280 jj_scanpos = xsp;
36281 if (jj_scan_token(374)) {
36282 jj_scanpos = xsp;
36283 if (jj_scan_token(164)) {
36284 jj_scanpos = xsp;
36285 if (jj_scan_token(165)) {
36286 jj_scanpos = xsp;
36287 if (jj_scan_token(166)) {
36288 jj_scanpos = xsp;
36289 if (jj_scan_token(168)) {
36290 jj_scanpos = xsp;
36291 if (jj_scan_token(169)) {
36292 jj_scanpos = xsp;
36293 if (jj_scan_token(170)) {
36294 jj_scanpos = xsp;
36295 if (jj_scan_token(173)) {
36296 jj_scanpos = xsp;
36297 if (jj_scan_token(397)) {
36298 jj_scanpos = xsp;
36299 if (jj_scan_token(368)) {
36300 jj_scanpos = xsp;
36301 if (jj_scan_token(174)) {
36302 jj_scanpos = xsp;
36303 if (jj_scan_token(306)) {
36304 jj_scanpos = xsp;
36305 if (jj_scan_token(402)) {
36306 jj_scanpos = xsp;
36307 if (jj_scan_token(315)) {
36308 jj_scanpos = xsp;
36309 if (jj_scan_token(356)) {
36310 jj_scanpos = xsp;
36311 if (jj_scan_token(176)) {
36312 jj_scanpos = xsp;
36313 if (jj_scan_token(179)) {
36314 jj_scanpos = xsp;
36315 if (jj_scan_token(357)) {
36316 jj_scanpos = xsp;
36317 if (jj_scan_token(304)) {
36318 jj_scanpos = xsp;
36319 if (jj_scan_token(307)) {
36320 jj_scanpos = xsp;
36321 if (jj_scan_token(193)) {
36322 jj_scanpos = xsp;
36323 if (jj_scan_token(196)) {
36324 jj_scanpos = xsp;
36325 if (jj_scan_token(326)) {
36326 jj_scanpos = xsp;
36327 if (jj_scan_token(199)) {
36328 jj_scanpos = xsp;
36329 if (jj_scan_token(200)) {
36330 jj_scanpos = xsp;
36331 if (jj_scan_token(205)) {
36332 jj_scanpos = xsp;
36333 if (jj_scan_token(206)) {
36334 jj_scanpos = xsp;
36335 if (jj_scan_token(208)) {
36336 jj_scanpos = xsp;
36337 if (jj_scan_token(209)) {
36338 jj_scanpos = xsp;
36339 if (jj_scan_token(371)) {
36340 jj_scanpos = xsp;
36341 if (jj_scan_token(327)) {
36342 jj_scanpos = xsp;
36343 if (jj_scan_token(211)) {
36344 jj_scanpos = xsp;
36345 if (jj_scan_token(302)) {
36346 jj_scanpos = xsp;
36347 if (jj_scan_token(219)) {
36348 jj_scanpos = xsp;
36349 if (jj_scan_token(383)) {
36350 jj_scanpos = xsp;
36351 if (jj_scan_token(223)) {
36352 jj_scanpos = xsp;
36353 if (jj_scan_token(384)) {
36354 jj_scanpos = xsp;
36355 if (jj_scan_token(226)) {
36356 jj_scanpos = xsp;
36357 if (jj_scan_token(228)) {
36358 jj_scanpos = xsp;
36359 if (jj_scan_token(229)) {
36360 jj_scanpos = xsp;
36361 if (jj_scan_token(230)) {
36362 jj_scanpos = xsp;
36363 if (jj_scan_token(232)) {
36364 jj_scanpos = xsp;
36365 if (jj_scan_token(385)) {
36366 jj_scanpos = xsp;
36367 if (jj_scan_token(235)) {
36368 jj_scanpos = xsp;
36369 if (jj_scan_token(237)) {
36370 jj_scanpos = xsp;
36371 if (jj_scan_token(238)) {
36372 jj_scanpos = xsp;
36373 if (jj_scan_token(239)) {
36374 jj_scanpos = xsp;
36375 if (jj_scan_token(394)) {
36376 jj_scanpos = xsp;
36377 if (jj_scan_token(241)) {
36378 jj_scanpos = xsp;
36379 if (jj_scan_token(242)) {
36380 jj_scanpos = xsp;
36381 if (jj_scan_token(244)) {
36382 jj_scanpos = xsp;
36383 if (jj_scan_token(245)) {
36384 jj_scanpos = xsp;
36385 if (jj_scan_token(243)) {
36386 jj_scanpos = xsp;
36387 if (jj_scan_token(247)) {
36388 jj_scanpos = xsp;
36389 if (jj_scan_token(248)) {
36390 jj_scanpos = xsp;
36391 if (jj_scan_token(358)) {
36392 jj_scanpos = xsp;
36393 if (jj_scan_token(249)) {
36394 jj_scanpos = xsp;
36395 if (jj_scan_token(251)) {
36396 jj_scanpos = xsp;
36397 if (jj_scan_token(359)) {
36398 jj_scanpos = xsp;
36399 if (jj_scan_token(407)) {
36400 jj_scanpos = xsp;
36401 if (jj_scan_token(253)) {
36402 jj_scanpos = xsp;
36403 if (jj_scan_token(410)) {
36404 jj_scanpos = xsp;
36405 if (jj_scan_token(360)) {
36406 jj_scanpos = xsp;
36407 if (jj_scan_token(257)) {
36408 jj_scanpos = xsp;
36409 if (jj_scan_token(361)) {
36410 jj_scanpos = xsp;
36411 if (jj_scan_token(362)) {
36412 jj_scanpos = xsp;
36413 if (jj_scan_token(262)) {
36414 jj_scanpos = xsp;
36415 if (jj_scan_token(363)) {
36416 jj_scanpos = xsp;
36417 if (jj_scan_token(369)) {
36418 jj_scanpos = xsp;
36419 if (jj_scan_token(398)) {
36420 jj_scanpos = xsp;
36421 if (jj_scan_token(265)) {
36422 jj_scanpos = xsp;
36423 if (jj_scan_token(264)) {
36424 jj_scanpos = xsp;
36425 if (jj_scan_token(266)) {
36426 jj_scanpos = xsp;
36427 if (jj_scan_token(364)) {
36428 jj_scanpos = xsp;
36429 if (jj_scan_token(373)) {
36430 jj_scanpos = xsp;
36431 if (jj_scan_token(272)) {
36432 jj_scanpos = xsp;
36433 if (jj_scan_token(274)) {
36434 jj_scanpos = xsp;
36435 if (jj_scan_token(275)) {
36436 jj_scanpos = xsp;
36437 if (jj_scan_token(277)) {
36438 jj_scanpos = xsp;
36439 if (jj_scan_token(279)) {
36440 jj_scanpos = xsp;
36441 if (jj_scan_token(278)) {
36442 jj_scanpos = xsp;
36443 if (jj_scan_token(276)) {
36444 jj_scanpos = xsp;
36445 if (jj_scan_token(400)) {
36446 jj_scanpos = xsp;
36447 if (jj_scan_token(281)) {
36448 jj_scanpos = xsp;
36449 if (jj_scan_token(391)) {
36450 jj_scanpos = xsp;
36451 if (jj_scan_token(392)) {
36452 jj_scanpos = xsp;
36453 if (jj_scan_token(365)) {
36454 jj_scanpos = xsp;
36455 if (jj_scan_token(386)) {
36456 jj_scanpos = xsp;
36457 if (jj_scan_token(286)) {
36458 jj_scanpos = xsp;
36459 if (jj_scan_token(309)) {
36460 jj_scanpos = xsp;
36461 if (jj_scan_token(412)) {
36462 jj_scanpos = xsp;
36463 if (jj_scan_token(288)) {
36464 jj_scanpos = xsp;
36465 if (jj_scan_token(310)) {
36466 jj_scanpos = xsp;
36467 if (jj_scan_token(387)) {
36468 jj_scanpos = xsp;
36469 if (jj_scan_token(311)) {
36470 jj_scanpos = xsp;
36471 if (jj_scan_token(388)) {
36472 jj_scanpos = xsp;
36473 if (jj_scan_token(316)) {
36474 jj_scanpos = xsp;
36475 if (jj_scan_token(293)) {
36476 jj_scanpos = xsp;
36477 if (jj_scan_token(319)) {
36478 jj_scanpos = xsp;
36479 if (jj_scan_token(294)) {
36480 jj_scanpos = xsp;
36481 if (jj_scan_token(366)) {
36482 jj_scanpos = xsp;
36483 if (jj_scan_token(270)) {
36484 jj_scanpos = xsp;
36485 if (jj_scan_token(100)) {
36486 jj_scanpos = xsp;
36487 if (jj_scan_token(182)) {
36488 jj_scanpos = xsp;
36489 if (jj_scan_token(378)) {
36490 jj_scanpos = xsp;
36491 if (jj_scan_token(186)) {
36492 jj_scanpos = xsp;
36493 if (jj_scan_token(233)) {
36494 jj_scanpos = xsp;
36495 if (jj_scan_token(231)) {
36496 jj_scanpos = xsp;
36497 if (jj_scan_token(43)) return true;
36498 }
36499 }
36500 }
36501 }
36502 }
36503 }
36504 }
36505 }
36506 }
36507 }
36508 }
36509 }
36510 }
36511 }
36512 }
36513 }
36514 }
36515 }
36516 }
36517 }
36518 }
36519 }
36520 }
36521 }
36522 }
36523 }
36524 }
36525 }
36526 }
36527 }
36528 }
36529 }
36530 }
36531 }
36532 }
36533 }
36534 }
36535 }
36536 }
36537 }
36538 }
36539 }
36540 }
36541 }
36542 }
36543 }
36544 }
36545 }
36546 }
36547 }
36548 }
36549 }
36550 }
36551 }
36552 }
36553 }
36554 }
36555 }
36556 }
36557 }
36558 }
36559 }
36560 }
36561 }
36562 }
36563 }
36564 }
36565 }
36566 }
36567 }
36568 }
36569 }
36570 }
36571 }
36572 }
36573 }
36574 }
36575 }
36576 }
36577 }
36578 }
36579 }
36580 }
36581 }
36582 }
36583 }
36584 }
36585 }
36586 }
36587 }
36588 }
36589 }
36590 }
36591 }
36592 }
36593 }
36594 }
36595 }
36596 }
36597 }
36598 }
36599 }
36600 }
36601 }
36602 }
36603 }
36604 }
36605 }
36606 }
36607 }
36608 }
36609 }
36610 }
36611 }
36612 }
36613 }
36614 }
36615 }
36616 }
36617 }
36618 }
36619 }
36620 }
36621 }
36622 }
36623 }
36624 }
36625 }
36626 }
36627 }
36628 }
36629 }
36630 }
36631 }
36632 }
36633 }
36634 }
36635 }
36636 }
36637 }
36638 }
36639 }
36640 }
36641 }
36642 }
36643 }
36644 }
36645 }
36646 }
36647 }
36648 }
36649 }
36650 }
36651 }
36652 }
36653 }
36654 }
36655 }
36656 }
36657 }
36658 }
36659 }
36660 }
36661 }
36662 }
36663 }
36664 }
36665 }
36666 }
36667 }
36668 }
36669 }
36670 }
36671 }
36672 }
36673 }
36674 }
36675 }
36676 }
36677 }
36678 }
36679 }
36680 }
36681 }
36682 }
36683 }
36684 }
36685 }
36686 }
36687 }
36688 }
36689 }
36690 }
36691 }
36692 }
36693 }
36694 }
36695 }
36696 }
36697 }
36698 }
36699 }
36700 }
36701 }
36702 }
36703 }
36704 }
36705 return false;
36706 }
36707
36708 private boolean jj_3_32() {
36709 if (jj_scan_token(INTERVAL)) return true;
36710 if (jj_scan_token(DAY)) return true;
36711 return false;
36712 }
36713
36714 private boolean jj_3_31() {
36715 if (jj_scan_token(INTERVAL)) return true;
36716 if (jj_scan_token(YEAR)) return true;
36717 return false;
36718 }
36719
36720 private boolean jj_3R_299() {
36721 if (jj_scan_token(5)) return true;
36722 Token xsp;
36723 xsp = jj_scanpos;
36724 if (jj_3R_342()) jj_scanpos = xsp;
36725 if (jj_scan_token(7)) return true;
36726 return false;
36727 }
36728
36729 private boolean jj_3R_353() {
36730 if (jj_scan_token(3)) return true;
36731 if (jj_3R_120()) return true;
36732 return false;
36733 }
36734
36735 private boolean jj_3R_205() {
36736 if (jj_scan_token(REF)) return true;
36737 if (jj_scan_token(CURSOR)) return true;
36738 return false;
36739 }
36740
36741 private boolean jj_3R_128() {
36742 if (jj_3R_143()) return true;
36743 Token xsp;
36744 while (true) {
36745 xsp = jj_scanpos;
36746 if (jj_3R_353()) { jj_scanpos = xsp; break; }
36747 }
36748 return false;
36749 }
36750
36751 private boolean jj_3_30() {
36752 if (jj_scan_token(LONG)) return true;
36753 if (jj_scan_token(RAW)) return true;
36754 return false;
36755 }
36756
36757 private boolean jj_3R_141() {
36758 if (jj_scan_token(3)) return true;
36759 return false;
36760 }
36761
36762 private boolean jj_3R_204() {
36763 Token xsp;
36764 xsp = jj_scanpos;
36765 if (jj_scan_token(67)) {
36766 jj_scanpos = xsp;
36767 if (jj_scan_token(320)) {
36768 jj_scanpos = xsp;
36769 if (jj_3_30()) {
36770 jj_scanpos = xsp;
36771 if (jj_scan_token(160)) {
36772 jj_scanpos = xsp;
36773 if (jj_scan_token(306)) {
36774 jj_scanpos = xsp;
36775 if (jj_scan_token(307)) {
36776 jj_scanpos = xsp;
36777 if (jj_scan_token(227)) {
36778 jj_scanpos = xsp;
36779 if (jj_scan_token(244)) {
36780 jj_scanpos = xsp;
36781 if (jj_scan_token(308)) {
36782 jj_scanpos = xsp;
36783 if (jj_scan_token(309)) {
36784 jj_scanpos = xsp;
36785 if (jj_scan_token(298)) {
36786 jj_scanpos = xsp;
36787 if (jj_scan_token(299)) {
36788 jj_scanpos = xsp;
36789 if (jj_scan_token(314)) {
36790 jj_scanpos = xsp;
36791 if (jj_scan_token(315)) return true;
36792 }
36793 }
36794 }
36795 }
36796 }
36797 }
36798 }
36799 }
36800 }
36801 }
36802 }
36803 }
36804 }
36805 return false;
36806 }
36807
36808 private boolean jj_3_58() {
36809 Token xsp;
36810 xsp = jj_scanpos;
36811 if (jj_3R_141()) {
36812 jj_scanpos = xsp;
36813 if (jj_3R_142()) return true;
36814 }
36815 if (jj_3R_120()) return true;
36816 return false;
36817 }
36818
36819 private boolean jj_3R_295() {
36820 if (jj_3R_143()) return true;
36821 Token xsp;
36822 while (true) {
36823 xsp = jj_scanpos;
36824 if (jj_3_58()) { jj_scanpos = xsp; break; }
36825 }
36826 return false;
36827 }
36828
36829 private boolean jj_3R_191() {
36830 if (jj_scan_token(21)) return true;
36831 if (jj_3R_143()) return true;
36832 if (jj_scan_token(22)) return true;
36833 return false;
36834 }
36835
36836 private boolean jj_3R_126() {
36837 Token xsp;
36838 xsp = jj_scanpos;
36839 if (jj_scan_token(188)) {
36840 jj_scanpos = xsp;
36841 if (jj_scan_token(189)) {
36842 jj_scanpos = xsp;
36843 if (jj_scan_token(68)) {
36844 jj_scanpos = xsp;
36845 if (jj_scan_token(190)) {
36846 jj_scanpos = xsp;
36847 if (jj_scan_token(191)) {
36848 jj_scanpos = xsp;
36849 if (jj_scan_token(192)) {
36850 jj_scanpos = xsp;
36851 if (jj_scan_token(59)) {
36852 jj_scanpos = xsp;
36853 if (jj_scan_token(301)) {
36854 jj_scanpos = xsp;
36855 if (jj_scan_token(91)) {
36856 jj_scanpos = xsp;
36857 if (jj_3R_203()) {
36858 jj_scanpos = xsp;
36859 if (jj_scan_token(120)) {
36860 jj_scanpos = xsp;
36861 if (jj_scan_token(303)) {
36862 jj_scanpos = xsp;
36863 if (jj_scan_token(146)) {
36864 jj_scanpos = xsp;
36865 if (jj_scan_token(174)) {
36866 jj_scanpos = xsp;
36867 if (jj_scan_token(175)) {
36868 jj_scanpos = xsp;
36869 if (jj_scan_token(187)) {
36870 jj_scanpos = xsp;
36871 if (jj_scan_token(304)) {
36872 jj_scanpos = xsp;
36873 if (jj_scan_token(215)) {
36874 jj_scanpos = xsp;
36875 if (jj_scan_token(216)) {
36876 jj_scanpos = xsp;
36877 if (jj_scan_token(217)) {
36878 jj_scanpos = xsp;
36879 if (jj_scan_token(228)) {
36880 jj_scanpos = xsp;
36881 if (jj_scan_token(305)) {
36882 jj_scanpos = xsp;
36883 if (jj_scan_token(256)) {
36884 jj_scanpos = xsp;
36885 if (jj_3R_204()) {
36886 jj_scanpos = xsp;
36887 if (jj_scan_token(61)) {
36888 jj_scanpos = xsp;
36889 if (jj_scan_token(312)) {
36890 jj_scanpos = xsp;
36891 if (jj_scan_token(313)) {
36892 jj_scanpos = xsp;
36893 if (jj_scan_token(270)) {
36894 jj_scanpos = xsp;
36895 if (jj_3R_205()) {
36896 jj_scanpos = xsp;
36897 if (jj_scan_token(88)) {
36898 jj_scanpos = xsp;
36899 if (jj_3_31()) {
36900 jj_scanpos = xsp;
36901 if (jj_3_32()) {
36902 jj_scanpos = xsp;
36903 if (jj_scan_token(274)) {
36904 jj_scanpos = xsp;
36905 if (jj_scan_token(275)) {
36906 jj_scanpos = xsp;
36907 if (jj_3R_206()) return true;
36908 }
36909 }
36910 }
36911 }
36912 }
36913 }
36914 }
36915 }
36916 }
36917 }
36918 }
36919 }
36920 }
36921 }
36922 }
36923 }
36924 }
36925 }
36926 }
36927 }
36928 }
36929 }
36930 }
36931 }
36932 }
36933 }
36934 }
36935 }
36936 }
36937 }
36938 }
36939 }
36940 }
36941 }
36942 xsp = jj_scanpos;
36943 if (jj_3_33()) jj_scanpos = xsp;
36944 xsp = jj_scanpos;
36945 if (jj_3R_207()) jj_scanpos = xsp;
36946 return false;
36947 }
36948
36949 private boolean jj_3R_240() {
36950 if (jj_scan_token(VARYING)) return true;
36951 if (jj_scan_token(ARRAY)) return true;
36952 return false;
36953 }
36954
36955 private boolean jj_3_29() {
36956 if (jj_scan_token(5)) return true;
36957 if (jj_3R_127()) return true;
36958 return false;
36959 }
36960
36961 private boolean jj_3R_127() {
36962 if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36963 return false;
36964 }
36965
36966 private boolean jj_3R_146() {
36967 Token xsp;
36968 xsp = jj_scanpos;
36969 if (jj_scan_token(271)) {
36970 jj_scanpos = xsp;
36971 if (jj_scan_token(310)) {
36972 jj_scanpos = xsp;
36973 if (jj_3R_240()) return true;
36974 }
36975 }
36976 xsp = jj_scanpos;
36977 if (jj_3_29()) jj_scanpos = xsp;
36978 return false;
36979 }
36980
36981 private boolean jj_3R_400() {
36982 if (jj_scan_token(CC_ELSE)) return true;
36983 if (jj_3R_236()) return true;
36984 return false;
36985 }
36986
36987 private boolean jj_3R_227() {
36988 if (jj_scan_token(A)) return true;
36989 if (jj_scan_token(SET)) return true;
36990 return false;
36991 }
36992
36993 private boolean jj_3R_137() {
36994 Token xsp;
36995 xsp = jj_scanpos;
36996 if (jj_3R_227()) {
36997 jj_scanpos = xsp;
36998 if (jj_scan_token(396)) return true;
36999 }
37000 return false;
37001 }
37002
37003 private boolean jj_3R_399() {
37004 if (jj_scan_token(CC_ELSIF)) return true;
37005 if (jj_3R_344()) return true;
37006 if (jj_scan_token(CC_THEN)) return true;
37007 if (jj_3R_236()) return true;
37008 return false;
37009 }
37010
37011 private boolean jj_3R_392() {
37012 if (jj_scan_token(NULL)) return true;
37013 return false;
37014 }
37015
37016 private boolean jj_3R_346() {
37017 if (jj_scan_token(CC_IF)) return true;
37018 if (jj_3R_344()) return true;
37019 if (jj_scan_token(CC_THEN)) return true;
37020 if (jj_3R_236()) return true;
37021 Token xsp;
37022 while (true) {
37023 xsp = jj_scanpos;
37024 if (jj_3R_399()) { jj_scanpos = xsp; break; }
37025 }
37026 while (true) {
37027 xsp = jj_scanpos;
37028 if (jj_3R_400()) { jj_scanpos = xsp; break; }
37029 }
37030 if (jj_scan_token(CC_END)) return true;
37031 return false;
37032 }
37033
37034 private boolean jj_3R_348() {
37035 if (jj_scan_token(11)) return true;
37036 Token xsp;
37037 xsp = jj_scanpos;
37038 if (jj_scan_token(284)) {
37039 jj_scanpos = xsp;
37040 if (jj_scan_token(246)) return true;
37041 }
37042 return false;
37043 }
37044
37045 private boolean jj_3R_347() {
37046 if (jj_scan_token(2)) return true;
37047 if (jj_3R_128()) return true;
37048 return false;
37049 }
37050
37051 private boolean jj_3_27() {
37052 if (jj_scan_token(REF)) return true;
37053 return false;
37054 }
37055
37056 private boolean jj_3R_305() {
37057 Token xsp;
37058 xsp = jj_scanpos;
37059 if (jj_3_27()) jj_scanpos = xsp;
37060 if (jj_3R_128()) return true;
37061 xsp = jj_scanpos;
37062 if (jj_3R_347()) jj_scanpos = xsp;
37063 xsp = jj_scanpos;
37064 if (jj_3R_348()) jj_scanpos = xsp;
37065 return false;
37066 }
37067
37068 private boolean jj_3_28() {
37069 if (jj_3R_126()) return true;
37070 return false;
37071 }
37072
37073 private boolean jj_3R_304() {
37074 if (jj_3R_346()) return true;
37075 return false;
37076 }
37077
37078 private boolean jj_3R_391() {
37079 Token xsp;
37080 xsp = jj_scanpos;
37081 if (jj_scan_token(283)) {
37082 jj_scanpos = xsp;
37083 if (jj_scan_token(117)) return true;
37084 }
37085 return false;
37086 }
37087
37088 private boolean jj_3R_236() {
37089 Token xsp;
37090 xsp = jj_scanpos;
37091 if (jj_3R_304()) {
37092 jj_scanpos = xsp;
37093 if (jj_3_28()) {
37094 jj_scanpos = xsp;
37095 if (jj_3R_305()) return true;
37096 }
37097 }
37098 return false;
37099 }
37100
37101 private boolean jj_3R_335() {
37102 if (jj_scan_token(_DEFAULT)) return true;
37103 return false;
37104 }
37105
37106 private boolean jj_3R_336() {
37107 if (jj_3R_234()) return true;
37108 return false;
37109 }
37110
37111 private boolean jj_3R_284() {
37112 if (jj_3R_124()) return true;
37113 return false;
37114 }
37115
37116 private boolean jj_3R_334() {
37117 if (jj_scan_token(9)) return true;
37118 if (jj_scan_token(10)) return true;
37119 return false;
37120 }
37121
37122 private boolean jj_3R_286() {
37123 Token xsp;
37124 xsp = jj_scanpos;
37125 if (jj_3R_334()) {
37126 jj_scanpos = xsp;
37127 if (jj_3R_335()) return true;
37128 }
37129 if (jj_3R_336()) return true;
37130 return false;
37131 }
37132
37133 private boolean jj_3R_333() {
37134 if (jj_scan_token(NOT)) return true;
37135 return false;
37136 }
37137
37138 private boolean jj_3R_183() {
37139 if (jj_scan_token(STRING_LITERAL)) return true;
37140 return false;
37141 }
37142
37143 private boolean jj_3R_285() {
37144 Token xsp;
37145 xsp = jj_scanpos;
37146 if (jj_3R_333()) jj_scanpos = xsp;
37147 if (jj_scan_token(NULL)) return true;
37148 return false;
37149 }
37150
37151 private boolean jj_3_26() {
37152 if (jj_scan_token(CONSTANT)) return true;
37153 return false;
37154 }
37155
37156 private boolean jj_3R_198() {
37157 if (jj_3R_284()) return true;
37158 Token xsp;
37159 xsp = jj_scanpos;
37160 if (jj_3_26()) jj_scanpos = xsp;
37161 if (jj_3R_236()) return true;
37162 xsp = jj_scanpos;
37163 if (jj_3R_285()) jj_scanpos = xsp;
37164 xsp = jj_scanpos;
37165 if (jj_3R_286()) jj_scanpos = xsp;
37166 return false;
37167 }
37168
37169 private boolean jj_3R_515() {
37170 if (jj_scan_token(6)) return true;
37171 if (jj_3R_475()) return true;
37172 return false;
37173 }
37174
37175 private boolean jj_3R_428() {
37176 if (jj_3R_475()) return true;
37177 Token xsp;
37178 while (true) {
37179 xsp = jj_scanpos;
37180 if (jj_3R_515()) { jj_scanpos = xsp; break; }
37181 }
37182 return false;
37183 }
37184
37185 private boolean jj_3R_197() {
37186 if (jj_3R_283()) return true;
37187 return false;
37188 }
37189
37190 private boolean jj_3R_386() {
37191 if (jj_scan_token(5)) return true;
37192 Token xsp;
37193 xsp = jj_scanpos;
37194 if (jj_3R_428()) jj_scanpos = xsp;
37195 if (jj_scan_token(7)) return true;
37196 return false;
37197 }
37198
37199 private boolean jj_3R_341() {
37200 if (jj_3R_393()) return true;
37201 return false;
37202 }
37203
37204 private boolean jj_3R_340() {
37205 if (jj_3R_392()) return true;
37206 return false;
37207 }
37208
37209 private boolean jj_3R_339() {
37210 if (jj_3R_391()) return true;
37211 return false;
37212 }
37213
37214 private boolean jj_3_23() {
37215 if (jj_scan_token(NOCOPY)) return true;
37216 return false;
37217 }
37218
37219 private boolean jj_3R_338() {
37220 if (jj_3R_183()) return true;
37221 return false;
37222 }
37223
37224 private boolean jj_3R_326() {
37225 if (jj_3R_386()) return true;
37226 return false;
37227 }
37228
37229 private boolean jj_3R_120() {
37230 Token xsp;
37231 xsp = jj_scanpos;
37232 if (jj_scan_token(420)) {
37233 jj_scanpos = xsp;
37234 if (jj_scan_token(428)) {
37235 jj_scanpos = xsp;
37236 if (jj_3R_197()) {
37237 jj_scanpos = xsp;
37238 if (jj_scan_token(35)) {
37239 jj_scanpos = xsp;
37240 if (jj_scan_token(38)) {
37241 jj_scanpos = xsp;
37242 if (jj_scan_token(39)) {
37243 jj_scanpos = xsp;
37244 if (jj_scan_token(40)) {
37245 jj_scanpos = xsp;
37246 if (jj_scan_token(41)) {
37247 jj_scanpos = xsp;
37248 if (jj_scan_token(50)) {
37249 jj_scanpos = xsp;
37250 if (jj_scan_token(56)) {
37251 jj_scanpos = xsp;
37252 if (jj_scan_token(59)) {
37253 jj_scanpos = xsp;
37254 if (jj_scan_token(60)) {
37255 jj_scanpos = xsp;
37256 if (jj_scan_token(61)) {
37257 jj_scanpos = xsp;
37258 if (jj_scan_token(67)) {
37259 jj_scanpos = xsp;
37260 if (jj_scan_token(68)) {
37261 jj_scanpos = xsp;
37262 if (jj_scan_token(79)) {
37263 jj_scanpos = xsp;
37264 if (jj_scan_token(85)) {
37265 jj_scanpos = xsp;
37266 if (jj_scan_token(88)) {
37267 jj_scanpos = xsp;
37268 if (jj_scan_token(91)) {
37269 jj_scanpos = xsp;
37270 if (jj_scan_token(93)) {
37271 jj_scanpos = xsp;
37272 if (jj_scan_token(98)) {
37273 jj_scanpos = xsp;
37274 if (jj_scan_token(103)) {
37275 jj_scanpos = xsp;
37276 if (jj_scan_token(111)) {
37277 jj_scanpos = xsp;
37278 if (jj_scan_token(112)) {
37279 jj_scanpos = xsp;
37280 if (jj_scan_token(120)) {
37281 jj_scanpos = xsp;
37282 if (jj_scan_token(122)) {
37283 jj_scanpos = xsp;
37284 if (jj_scan_token(146)) {
37285 jj_scanpos = xsp;
37286 if (jj_scan_token(147)) {
37287 jj_scanpos = xsp;
37288 if (jj_scan_token(160)) {
37289 jj_scanpos = xsp;
37290 if (jj_scan_token(161)) {
37291 jj_scanpos = xsp;
37292 if (jj_scan_token(171)) {
37293 jj_scanpos = xsp;
37294 if (jj_scan_token(175)) {
37295 jj_scanpos = xsp;
37296 if (jj_scan_token(178)) {
37297 jj_scanpos = xsp;
37298 if (jj_scan_token(181)) {
37299 jj_scanpos = xsp;
37300 if (jj_scan_token(187)) {
37301 jj_scanpos = xsp;
37302 if (jj_scan_token(188)) {
37303 jj_scanpos = xsp;
37304 if (jj_scan_token(189)) {
37305 jj_scanpos = xsp;
37306 if (jj_scan_token(190)) {
37307 jj_scanpos = xsp;
37308 if (jj_scan_token(191)) {
37309 jj_scanpos = xsp;
37310 if (jj_scan_token(192)) {
37311 jj_scanpos = xsp;
37312 if (jj_scan_token(194)) {
37313 jj_scanpos = xsp;
37314 if (jj_scan_token(201)) {
37315 jj_scanpos = xsp;
37316 if (jj_scan_token(207)) {
37317 jj_scanpos = xsp;
37318 if (jj_scan_token(215)) {
37319 jj_scanpos = xsp;
37320 if (jj_scan_token(216)) {
37321 jj_scanpos = xsp;
37322 if (jj_scan_token(217)) {
37323 jj_scanpos = xsp;
37324 if (jj_scan_token(218)) {
37325 jj_scanpos = xsp;
37326 if (jj_scan_token(220)) {
37327 jj_scanpos = xsp;
37328 if (jj_scan_token(222)) {
37329 jj_scanpos = xsp;
37330 if (jj_scan_token(221)) {
37331 jj_scanpos = xsp;
37332 if (jj_scan_token(225)) {
37333 jj_scanpos = xsp;
37334 if (jj_scan_token(227)) {
37335 jj_scanpos = xsp;
37336 if (jj_scan_token(246)) {
37337 jj_scanpos = xsp;
37338 if (jj_scan_token(252)) {
37339 jj_scanpos = xsp;
37340 if (jj_scan_token(256)) {
37341 jj_scanpos = xsp;
37342 if (jj_scan_token(259)) {
37343 jj_scanpos = xsp;
37344 if (jj_scan_token(260)) {
37345 jj_scanpos = xsp;
37346 if (jj_scan_token(263)) {
37347 jj_scanpos = xsp;
37348 if (jj_scan_token(267)) {
37349 jj_scanpos = xsp;
37350 if (jj_scan_token(268)) {
37351 jj_scanpos = xsp;
37352 if (jj_scan_token(269)) {
37353 jj_scanpos = xsp;
37354 if (jj_scan_token(282)) {
37355 jj_scanpos = xsp;
37356 if (jj_scan_token(284)) {
37357 jj_scanpos = xsp;
37358 if (jj_scan_token(285)) {
37359 jj_scanpos = xsp;
37360 if (jj_scan_token(298)) {
37361 jj_scanpos = xsp;
37362 if (jj_scan_token(299)) {
37363 jj_scanpos = xsp;
37364 if (jj_scan_token(303)) {
37365 jj_scanpos = xsp;
37366 if (jj_scan_token(305)) {
37367 jj_scanpos = xsp;
37368 if (jj_scan_token(308)) {
37369 jj_scanpos = xsp;
37370 if (jj_scan_token(292)) return true;
37371 }
37372 }
37373 }
37374 }
37375 }
37376 }
37377 }
37378 }
37379 }
37380 }
37381 }
37382 }
37383 }
37384 }
37385 }
37386 }
37387 }
37388 }
37389 }
37390 }
37391 }
37392 }
37393 }
37394 }
37395 }
37396 }
37397 }
37398 }
37399 }
37400 }
37401 }
37402 }
37403 }
37404 }
37405 }
37406 }
37407 }
37408 }
37409 }
37410 }
37411 }
37412 }
37413 }
37414 }
37415 }
37416 }
37417 }
37418 }
37419 }
37420 }
37421 }
37422 }
37423 }
37424 }
37425 }
37426 }
37427 }
37428 }
37429 }
37430 }
37431 }
37432 }
37433 }
37434 }
37435 }
37436 }
37437 }
37438 }
37439 }
37440 return false;
37441 }
37442
37443 private boolean jj_3R_337() {
37444 if (jj_3R_127()) return true;
37445 return false;
37446 }
37447
37448 private boolean jj_3R_294() {
37449 Token xsp;
37450 xsp = jj_scanpos;
37451 if (jj_3R_337()) {
37452 jj_scanpos = xsp;
37453 if (jj_scan_token(425)) {
37454 jj_scanpos = xsp;
37455 if (jj_3R_338()) {
37456 jj_scanpos = xsp;
37457 if (jj_3R_339()) {
37458 jj_scanpos = xsp;
37459 if (jj_3R_340()) {
37460 jj_scanpos = xsp;
37461 if (jj_3R_341()) return true;
37462 }
37463 }
37464 }
37465 }
37466 }
37467 return false;
37468 }
37469
37470 private boolean jj_3R_325() {
37471 if (jj_scan_token(RETURN)) return true;
37472 if (jj_3R_236()) return true;
37473 return false;
37474 }
37475
37476 private boolean jj_3R_479() {
37477 if (jj_3R_234()) return true;
37478 return false;
37479 }
37480
37481 private boolean jj_3R_279() {
37482 if (jj_scan_token(PROCEDURE)) return true;
37483 if (jj_3R_155()) return true;
37484 Token xsp;
37485 xsp = jj_scanpos;
37486 if (jj_3R_326()) jj_scanpos = xsp;
37487 return false;
37488 }
37489
37490 private boolean jj_3R_478() {
37491 if (jj_3R_183()) return true;
37492 return false;
37493 }
37494
37495 private boolean jj_3R_477() {
37496 if (jj_scan_token(SESSIONTIMEZONE)) return true;
37497 return false;
37498 }
37499
37500 private boolean jj_3R_476() {
37501 if (jj_scan_token(DBTIMEZONE)) return true;
37502 return false;
37503 }
37504
37505 private boolean jj_3R_464() {
37506 if (jj_3R_124()) return true;
37507 return false;
37508 }
37509
37510 private boolean jj_3R_125() {
37511 if (jj_scan_token(IN)) return true;
37512 if (jj_scan_token(OUT)) return true;
37513 return false;
37514 }
37515
37516 private boolean jj_3R_298() {
37517 if (jj_scan_token(TIME)) return true;
37518 if (jj_scan_token(ZONE)) return true;
37519 Token xsp;
37520 xsp = jj_scanpos;
37521 if (jj_3R_476()) {
37522 jj_scanpos = xsp;
37523 if (jj_3R_477()) {
37524 jj_scanpos = xsp;
37525 if (jj_3R_478()) {
37526 jj_scanpos = xsp;
37527 if (jj_3R_479()) return true;
37528 }
37529 }
37530 }
37531 return false;
37532 }
37533
37534 private boolean jj_3R_226() {
37535 if (jj_3R_299()) return true;
37536 return false;
37537 }
37538
37539 private boolean jj_3R_297() {
37540 if (jj_scan_token(LOCAL)) return true;
37541 return false;
37542 }
37543
37544 private boolean jj_3R_238() {
37545 if (jj_3R_283()) return true;
37546 return false;
37547 }
37548
37549 private boolean jj_3R_324() {
37550 if (jj_3R_386()) return true;
37551 return false;
37552 }
37553
37554 private boolean jj_3R_278() {
37555 if (jj_scan_token(FUNCTION)) return true;
37556 if (jj_3R_155()) return true;
37557 Token xsp;
37558 xsp = jj_scanpos;
37559 if (jj_3R_324()) jj_scanpos = xsp;
37560 xsp = jj_scanpos;
37561 if (jj_3R_325()) jj_scanpos = xsp;
37562 return false;
37563 }
37564
37565 private boolean jj_3R_225() {
37566 if (jj_scan_token(AT)) return true;
37567 Token xsp;
37568 xsp = jj_scanpos;
37569 if (jj_3R_297()) {
37570 jj_scanpos = xsp;
37571 if (jj_3R_298()) return true;
37572 }
37573 return false;
37574 }
37575
37576 private boolean jj_3R_625() {
37577 if (jj_scan_token(3)) return true;
37578 if (jj_3R_124()) return true;
37579 return false;
37580 }
37581
37582 private boolean jj_3R_194() {
37583 Token xsp;
37584 xsp = jj_scanpos;
37585 if (jj_3R_278()) {
37586 jj_scanpos = xsp;
37587 if (jj_3R_279()) return true;
37588 }
37589 return false;
37590 }
37591
37592 private boolean jj_3R_224() {
37593 if (jj_scan_token(2)) return true;
37594 if (jj_3R_120()) return true;
37595 return false;
37596 }
37597
37598 private boolean jj_3R_624() {
37599 if (jj_scan_token(6)) return true;
37600 if (jj_3R_124()) return true;
37601 return false;
37602 }
37603
37604 private boolean jj_3R_143() {
37605 Token xsp;
37606 xsp = jj_scanpos;
37607 if (jj_scan_token(420)) {
37608 jj_scanpos = xsp;
37609 if (jj_scan_token(428)) {
37610 jj_scanpos = xsp;
37611 if (jj_3R_238()) {
37612 jj_scanpos = xsp;
37613 if (jj_scan_token(60)) {
37614 jj_scanpos = xsp;
37615 if (jj_scan_token(171)) {
37616 jj_scanpos = xsp;
37617 if (jj_scan_token(201)) {
37618 jj_scanpos = xsp;
37619 if (jj_scan_token(222)) {
37620 jj_scanpos = xsp;
37621 if (jj_scan_token(227)) {
37622 jj_scanpos = xsp;
37623 if (jj_scan_token(35)) {
37624 jj_scanpos = xsp;
37625 if (jj_scan_token(308)) {
37626 jj_scanpos = xsp;
37627 if (jj_scan_token(258)) {
37628 jj_scanpos = xsp;
37629 if (jj_scan_token(259)) {
37630 jj_scanpos = xsp;
37631 if (jj_scan_token(260)) {
37632 jj_scanpos = xsp;
37633 if (jj_scan_token(269)) {
37634 jj_scanpos = xsp;
37635 if (jj_scan_token(284)) {
37636 jj_scanpos = xsp;
37637 if (jj_scan_token(161)) {
37638 jj_scanpos = xsp;
37639 if (jj_scan_token(303)) {
37640 jj_scanpos = xsp;
37641 if (jj_scan_token(50)) return true;
37642 }
37643 }
37644 }
37645 }
37646 }
37647 }
37648 }
37649 }
37650 }
37651 }
37652 }
37653 }
37654 }
37655 }
37656 }
37657 }
37658 }
37659 return false;
37660 }
37661
37662 private boolean jj_3_24() {
37663 Token xsp;
37664 xsp = jj_scanpos;
37665 if (jj_scan_token(207)) {
37666 jj_scanpos = xsp;
37667 if (jj_3R_125()) return true;
37668 }
37669 xsp = jj_scanpos;
37670 if (jj_3_23()) jj_scanpos = xsp;
37671 return false;
37672 }
37673
37674 private boolean jj_3R_636() {
37675 if (jj_scan_token(NOT)) return true;
37676 return false;
37677 }
37678
37679 private boolean jj_3R_223() {
37680 if (jj_scan_token(3)) return true;
37681 if (jj_3R_120()) return true;
37682 return false;
37683 }
37684
37685 private boolean jj_3R_136() {
37686 Token xsp;
37687 xsp = jj_scanpos;
37688 if (jj_3R_223()) {
37689 jj_scanpos = xsp;
37690 if (jj_3R_224()) {
37691 jj_scanpos = xsp;
37692 if (jj_3R_225()) {
37693 jj_scanpos = xsp;
37694 if (jj_3R_226()) return true;
37695 }
37696 }
37697 }
37698 return false;
37699 }
37700
37701 private boolean jj_3R_560() {
37702 if (jj_3R_236()) return true;
37703 return false;
37704 }
37705
37706 private boolean jj_3R_463() {
37707 if (jj_3R_351()) return true;
37708 return false;
37709 }
37710
37711 private boolean jj_3R_601() {
37712 if (jj_scan_token(6)) return true;
37713 if (jj_3R_124()) return true;
37714 Token xsp;
37715 xsp = jj_scanpos;
37716 if (jj_3R_625()) jj_scanpos = xsp;
37717 return false;
37718 }
37719
37720 private boolean jj_3R_487() {
37721 if (jj_scan_token(3)) return true;
37722 if (jj_3R_124()) return true;
37723 return false;
37724 }
37725
37726 private boolean jj_3R_471() {
37727 if (jj_3R_147()) return true;
37728 return false;
37729 }
37730
37731 private boolean jj_3R_470() {
37732 if (jj_3R_118()) return true;
37733 return false;
37734 }
37735
37736 private boolean jj_3R_631() {
37737 if (jj_scan_token(NOT)) return true;
37738 return false;
37739 }
37740
37741 private boolean jj_3R_426() {
37742 Token xsp;
37743 xsp = jj_scanpos;
37744 if (jj_3R_470()) {
37745 jj_scanpos = xsp;
37746 if (jj_3R_471()) return true;
37747 }
37748 return false;
37749 }
37750
37751 private boolean jj_3R_598() {
37752 if (jj_scan_token(9)) return true;
37753 if (jj_scan_token(10)) return true;
37754 return false;
37755 }
37756
37757 private boolean jj_3_57() {
37758 Token xsp;
37759 if (jj_scan_token(5)) return true;
37760 while (true) {
37761 xsp = jj_scanpos;
37762 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37763 }
37764 if (jj_scan_token(WITH)) return true;
37765 return false;
37766 }
37767
37768 private boolean jj_3R_561() {
37769 Token xsp;
37770 xsp = jj_scanpos;
37771 if (jj_3R_598()) {
37772 jj_scanpos = xsp;
37773 if (jj_scan_token(92)) return true;
37774 }
37775 if (jj_3R_234()) return true;
37776 return false;
37777 }
37778
37779 private boolean jj_3_56() {
37780 if (jj_scan_token(WITH)) return true;
37781 return false;
37782 }
37783
37784 private boolean jj_3_55() {
37785 Token xsp;
37786 if (jj_scan_token(5)) return true;
37787 while (true) {
37788 xsp = jj_scanpos;
37789 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37790 }
37791 if (jj_scan_token(SELECT)) return true;
37792 return false;
37793 }
37794
37795 private boolean jj_3_25() {
37796 Token xsp;
37797 xsp = jj_scanpos;
37798 if (jj_3_24()) {
37799 jj_scanpos = xsp;
37800 if (jj_scan_token(137)) return true;
37801 }
37802 return false;
37803 }
37804
37805 private boolean jj_3_54() {
37806 if (jj_scan_token(SELECT)) return true;
37807 return false;
37808 }
37809
37810 private boolean jj_3R_296() {
37811 if (jj_scan_token(6)) return true;
37812 if (jj_3R_234()) return true;
37813 return false;
37814 }
37815
37816 private boolean jj_3_53() {
37817 if (jj_3R_140()) return true;
37818 return false;
37819 }
37820
37821 private boolean jj_3R_600() {
37822 if (jj_scan_token(3)) return true;
37823 if (jj_3R_124()) return true;
37824 return false;
37825 }
37826
37827 private boolean jj_3_52() {
37828 if (jj_3R_139()) return true;
37829 return false;
37830 }
37831
37832 private boolean jj_3R_517() {
37833 if (jj_3R_124()) return true;
37834 return false;
37835 }
37836
37837 private boolean jj_3R_462() {
37838 if (jj_3R_174()) return true;
37839 return false;
37840 }
37841
37842 private boolean jj_3R_222() {
37843 if (jj_scan_token(5)) return true;
37844 if (jj_3R_234()) return true;
37845 Token xsp;
37846 while (true) {
37847 xsp = jj_scanpos;
37848 if (jj_3R_296()) { jj_scanpos = xsp; break; }
37849 }
37850 if (jj_scan_token(7)) return true;
37851 return false;
37852 }
37853
37854 private boolean jj_3_51() {
37855 if (jj_3R_138()) return true;
37856 return false;
37857 }
37858
37859 private boolean jj_3R_461() {
37860 if (jj_3R_423()) return true;
37861 return false;
37862 }
37863
37864 private boolean jj_3R_388() {
37865 if (jj_scan_token(USING)) return true;
37866 if (jj_3R_124()) return true;
37867 Token xsp;
37868 xsp = jj_scanpos;
37869 if (jj_3R_487()) jj_scanpos = xsp;
37870 return false;
37871 }
37872
37873 private boolean jj_3_50() {
37874 if (jj_3R_137()) return true;
37875 return false;
37876 }
37877
37878 private boolean jj_3R_221() {
37879 if (jj_scan_token(5)) return true;
37880 if (jj_3R_180()) return true;
37881 if (jj_scan_token(7)) return true;
37882 return false;
37883 }
37884
37885 private boolean jj_3R_220() {
37886 if (jj_scan_token(WITH)) return true;
37887 if (jj_3R_180()) return true;
37888 return false;
37889 }
37890
37891 private boolean jj_3R_219() {
37892 if (jj_scan_token(5)) return true;
37893 if (jj_3R_180()) return true;
37894 if (jj_scan_token(7)) return true;
37895 return false;
37896 }
37897
37898 private boolean jj_3R_475() {
37899 if (jj_3R_124()) return true;
37900 Token xsp;
37901 xsp = jj_scanpos;
37902 if (jj_3_25()) jj_scanpos = xsp;
37903 xsp = jj_scanpos;
37904 if (jj_scan_token(8)) {
37905 jj_scanpos = xsp;
37906 if (jj_3R_560()) return true;
37907 }
37908 xsp = jj_scanpos;
37909 if (jj_3R_561()) jj_scanpos = xsp;
37910 return false;
37911 }
37912
37913 private boolean jj_3R_218() {
37914 if (jj_scan_token(SELECT)) return true;
37915 if (jj_3R_180()) return true;
37916 return false;
37917 }
37918
37919 private boolean jj_3R_217() {
37920 if (jj_3R_295()) return true;
37921 return false;
37922 }
37923
37924 private boolean jj_3R_216() {
37925 if (jj_3R_140()) return true;
37926 return false;
37927 }
37928
37929 private boolean jj_3R_215() {
37930 if (jj_3R_139()) return true;
37931 return false;
37932 }
37933
37934 private boolean jj_3R_214() {
37935 if (jj_3R_138()) return true;
37936 return false;
37937 }
37938
37939 private boolean jj_3R_213() {
37940 if (jj_3R_137()) return true;
37941 return false;
37942 }
37943
37944 private boolean jj_3R_516() {
37945 if (jj_scan_token(3)) return true;
37946 if (jj_3R_124()) return true;
37947 return false;
37948 }
37949
37950 private boolean jj_3R_212() {
37951 if (jj_3R_294()) return true;
37952 return false;
37953 }
37954
37955 private boolean jj_3R_332() {
37956 if (jj_3R_192()) return true;
37957 if (jj_scan_token(BEGIN)) return true;
37958 Token xsp;
37959 xsp = jj_scanpos;
37960 if (jj_3R_461()) jj_scanpos = xsp;
37961 while (true) {
37962 xsp = jj_scanpos;
37963 if (jj_3R_462()) { jj_scanpos = xsp; break; }
37964 }
37965 xsp = jj_scanpos;
37966 if (jj_3R_463()) jj_scanpos = xsp;
37967 if (jj_scan_token(END)) return true;
37968 xsp = jj_scanpos;
37969 if (jj_3R_464()) jj_scanpos = xsp;
37970 return false;
37971 }
37972
37973 private boolean jj_3_22() {
37974 if (jj_3R_124()) return true;
37975 if (jj_scan_token(3)) return true;
37976 return false;
37977 }
37978
37979 private boolean jj_3R_135() {
37980 Token xsp;
37981 xsp = jj_scanpos;
37982 if (jj_3R_212()) {
37983 jj_scanpos = xsp;
37984 if (jj_3R_213()) {
37985 jj_scanpos = xsp;
37986 if (jj_3R_214()) {
37987 jj_scanpos = xsp;
37988 if (jj_3R_215()) {
37989 jj_scanpos = xsp;
37990 if (jj_3R_216()) {
37991 jj_scanpos = xsp;
37992 if (jj_3R_217()) {
37993 jj_scanpos = xsp;
37994 if (jj_3R_218()) {
37995 jj_scanpos = xsp;
37996 if (jj_3R_219()) {
37997 jj_scanpos = xsp;
37998 if (jj_3R_220()) {
37999 jj_scanpos = xsp;
38000 if (jj_3R_221()) {
38001 jj_scanpos = xsp;
38002 if (jj_3R_222()) return true;
38003 }
38004 }
38005 }
38006 }
38007 }
38008 }
38009 }
38010 }
38011 }
38012 }
38013 return false;
38014 }
38015
38016 private boolean jj_3_21() {
38017 if (jj_3R_123()) return true;
38018 return false;
38019 }
38020
38021 private boolean jj_3_49() {
38022 if (jj_3R_136()) return true;
38023 return false;
38024 }
38025
38026 private boolean jj_3_48() {
38027 if (jj_scan_token(NEW)) return true;
38028 if (jj_3R_135()) return true;
38029 return false;
38030 }
38031
38032 private boolean jj_3R_155() {
38033 Token xsp;
38034 xsp = jj_scanpos;
38035 if (jj_3_22()) jj_scanpos = xsp;
38036 if (jj_3R_124()) return true;
38037 return false;
38038 }
38039
38040 private boolean jj_3R_293() {
38041 if (jj_3R_135()) return true;
38042 return false;
38043 }
38044
38045 private boolean jj_3R_390() {
38046 if (jj_scan_token(RELIES_ON)) return true;
38047 if (jj_scan_token(5)) return true;
38048 if (jj_3R_124()) return true;
38049 Token xsp;
38050 xsp = jj_scanpos;
38051 if (jj_3R_600()) jj_scanpos = xsp;
38052 while (true) {
38053 xsp = jj_scanpos;
38054 if (jj_3R_601()) { jj_scanpos = xsp; break; }
38055 }
38056 if (jj_scan_token(7)) return true;
38057 return false;
38058 }
38059
38060 private boolean jj_3R_387() {
38061 if (jj_3R_429()) return true;
38062 return false;
38063 }
38064
38065 private boolean jj_3R_431() {
38066 Token xsp;
38067 xsp = jj_scanpos;
38068 if (jj_scan_token(204)) {
38069 jj_scanpos = xsp;
38070 if (jj_scan_token(71)) return true;
38071 }
38072 xsp = jj_scanpos;
38073 if (jj_3R_517()) jj_scanpos = xsp;
38074 if (jj_scan_token(BY)) return true;
38075 if (jj_scan_token(5)) return true;
38076 if (jj_3R_124()) return true;
38077 while (true) {
38078 xsp = jj_scanpos;
38079 if (jj_3R_624()) { jj_scanpos = xsp; break; }
38080 }
38081 if (jj_scan_token(7)) return true;
38082 return false;
38083 }
38084
38085 private boolean jj_3R_282() {
38086 Token xsp;
38087 xsp = jj_scanpos;
38088 if (jj_scan_token(152)) {
38089 jj_scanpos = xsp;
38090 if (jj_scan_token(51)) return true;
38091 }
38092 xsp = jj_scanpos;
38093 if (jj_3_21()) {
38094 jj_scanpos = xsp;
38095 if (jj_3R_332()) return true;
38096 }
38097 return false;
38098 }
38099
38100 private boolean jj_3R_292() {
38101 if (jj_scan_token(NEW)) return true;
38102 if (jj_3R_135()) return true;
38103 return false;
38104 }
38105
38106 private boolean jj_3R_430() {
38107 if (jj_scan_token(USING)) return true;
38108 if (jj_3R_124()) return true;
38109 Token xsp;
38110 xsp = jj_scanpos;
38111 if (jj_3R_516()) jj_scanpos = xsp;
38112 return false;
38113 }
38114
38115 private boolean jj_3R_389() {
38116 Token xsp;
38117 xsp = jj_scanpos;
38118 if (jj_3R_430()) {
38119 jj_scanpos = xsp;
38120 if (jj_3R_431()) return true;
38121 }
38122 return false;
38123 }
38124
38125 private boolean jj_3R_637() {
38126 if (jj_scan_token(6)) return true;
38127 Token xsp;
38128 xsp = jj_scanpos;
38129 if (jj_scan_token(198)) jj_scanpos = xsp;
38130 if (jj_3R_295()) return true;
38131 return false;
38132 }
38133
38134 private boolean jj_3R_211() {
38135 Token xsp;
38136 xsp = jj_scanpos;
38137 if (jj_3R_292()) {
38138 jj_scanpos = xsp;
38139 if (jj_3R_293()) return true;
38140 }
38141 while (true) {
38142 xsp = jj_scanpos;
38143 if (jj_3_49()) { jj_scanpos = xsp; break; }
38144 }
38145 return false;
38146 }
38147
38148 private boolean jj_3R_277() {
38149 Token xsp;
38150 xsp = jj_scanpos;
38151 if (jj_scan_token(100)) {
38152 jj_scanpos = xsp;
38153 if (jj_scan_token(182)) return true;
38154 }
38155 return false;
38156 }
38157
38158 private boolean jj_3R_210() {
38159 if (jj_scan_token(NEW_DOT)) return true;
38160 if (jj_3R_120()) return true;
38161 return false;
38162 }
38163
38164 private boolean jj_3R_133() {
38165 Token xsp;
38166 xsp = jj_scanpos;
38167 if (jj_3R_210()) {
38168 jj_scanpos = xsp;
38169 if (jj_3R_211()) return true;
38170 }
38171 return false;
38172 }
38173
38174 private boolean jj_3R_281() {
38175 if (jj_scan_token(AGGREGATE)) return true;
38176 if (jj_scan_token(USING)) return true;
38177 if (jj_3R_124()) return true;
38178 return false;
38179 }
38180
38181 private boolean jj_3R_331() {
38182 if (jj_scan_token(RESULT_CACHE)) return true;
38183 Token xsp;
38184 xsp = jj_scanpos;
38185 if (jj_3R_390()) jj_scanpos = xsp;
38186 return false;
38187 }
38188
38189 private boolean jj_3R_330() {
38190 if (jj_scan_token(PIPELINED)) return true;
38191 Token xsp;
38192 xsp = jj_scanpos;
38193 if (jj_3R_389()) jj_scanpos = xsp;
38194 return false;
38195 }
38196
38197 private boolean jj_3R_329() {
38198 if (jj_scan_token(PARALLEL_ENABLE)) return true;
38199 Token xsp;
38200 xsp = jj_scanpos;
38201 if (jj_3R_387()) jj_scanpos = xsp;
38202 xsp = jj_scanpos;
38203 if (jj_3R_388()) jj_scanpos = xsp;
38204 return false;
38205 }
38206
38207 private boolean jj_3R_328() {
38208 if (jj_3R_239()) return true;
38209 return false;
38210 }
38211
38212 private boolean jj_3_47() {
38213 if (jj_scan_token(IDENTIFIER)) return true;
38214 if (jj_scan_token(IS)) return true;
38215 return false;
38216 }
38217
38218 private boolean jj_3R_280() {
38219 Token xsp;
38220 xsp = jj_scanpos;
38221 if (jj_3R_327()) {
38222 jj_scanpos = xsp;
38223 if (jj_scan_token(95)) {
38224 jj_scanpos = xsp;
38225 if (jj_3R_328()) {
38226 jj_scanpos = xsp;
38227 if (jj_3R_329()) {
38228 jj_scanpos = xsp;
38229 if (jj_3R_330()) {
38230 jj_scanpos = xsp;
38231 if (jj_3R_331()) return true;
38232 }
38233 }
38234 }
38235 }
38236 }
38237 return false;
38238 }
38239
38240 private boolean jj_3R_327() {
38241 if (jj_scan_token(AUTHID)) return true;
38242 Token xsp;
38243 xsp = jj_scanpos;
38244 if (jj_scan_token(37)) {
38245 jj_scanpos = xsp;
38246 if (jj_scan_token(36)) return true;
38247 }
38248 return false;
38249 }
38250
38251 private boolean jj_3R_134() {
38252 if (jj_scan_token(NOT)) return true;
38253 if (jj_scan_token(NULL)) return true;
38254 return false;
38255 }
38256
38257 private boolean jj_3R_196() {
38258 Token xsp;
38259 while (true) {
38260 xsp = jj_scanpos;
38261 if (jj_3R_280()) { jj_scanpos = xsp; break; }
38262 }
38263 xsp = jj_scanpos;
38264 if (jj_3R_281()) jj_scanpos = xsp;
38265 xsp = jj_scanpos;
38266 if (jj_3R_282()) jj_scanpos = xsp;
38267 if (jj_scan_token(4)) return true;
38268 return false;
38269 }
38270
38271 private boolean jj_3R_635() {
38272 if (jj_3R_133()) return true;
38273 return false;
38274 }
38275
38276 private boolean jj_3R_276() {
38277 if (jj_scan_token(OR)) return true;
38278 if (jj_scan_token(REPLACE)) return true;
38279 return false;
38280 }
38281
38282 private boolean jj_3R_634() {
38283 if (jj_3R_295()) return true;
38284 if (jj_scan_token(IS)) return true;
38285 Token xsp;
38286 xsp = jj_scanpos;
38287 if (jj_3R_636()) jj_scanpos = xsp;
38288 if (jj_scan_token(OF)) return true;
38289 xsp = jj_scanpos;
38290 if (jj_scan_token(284)) jj_scanpos = xsp;
38291 if (jj_scan_token(5)) return true;
38292 xsp = jj_scanpos;
38293 if (jj_scan_token(198)) jj_scanpos = xsp;
38294 if (jj_3R_295()) return true;
38295 while (true) {
38296 xsp = jj_scanpos;
38297 if (jj_3R_637()) { jj_scanpos = xsp; break; }
38298 }
38299 if (jj_scan_token(7)) return true;
38300 return false;
38301 }
38302
38303 private boolean jj_3R_195() {
38304 if (jj_3R_249()) return true;
38305 return false;
38306 }
38307
38308 private boolean jj_3R_632() {
38309 Token xsp;
38310 xsp = jj_scanpos;
38311 if (jj_3R_634()) {
38312 jj_scanpos = xsp;
38313 if (jj_3R_635()) return true;
38314 }
38315 return false;
38316 }
38317
38318 private boolean jj_3R_193() {
38319 if (jj_scan_token(CREATE)) return true;
38320 Token xsp;
38321 xsp = jj_scanpos;
38322 if (jj_3R_276()) jj_scanpos = xsp;
38323 xsp = jj_scanpos;
38324 if (jj_3R_277()) jj_scanpos = xsp;
38325 return false;
38326 }
38327
38328 private boolean jj_3R_118() {
38329 Token xsp;
38330 xsp = jj_scanpos;
38331 if (jj_3R_193()) jj_scanpos = xsp;
38332 if (jj_3R_194()) return true;
38333 xsp = jj_scanpos;
38334 if (jj_3R_195()) {
38335 jj_scanpos = xsp;
38336 if (jj_3R_196()) return true;
38337 }
38338 return false;
38339 }
38340
38341 private boolean jj_3_46() {
38342 if (jj_scan_token(IDENTIFIER)) return true;
38343 if (jj_scan_token(IS)) return true;
38344 Token xsp;
38345 xsp = jj_scanpos;
38346 if (jj_3R_134()) {
38347 jj_scanpos = xsp;
38348 if (jj_scan_token(185)) return true;
38349 }
38350 return false;
38351 }
38352
38353 private boolean jj_3R_627() {
38354 if (jj_3R_632()) return true;
38355 return false;
38356 }
38357
38358 private boolean jj_3R_626() {
38359 if (jj_3R_295()) return true;
38360 if (jj_scan_token(IS)) return true;
38361 Token xsp;
38362 xsp = jj_scanpos;
38363 if (jj_3R_631()) jj_scanpos = xsp;
38364 if (jj_scan_token(NULL)) return true;
38365 return false;
38366 }
38367
38368 private boolean jj_3R_535() {
38369 if (jj_scan_token(CC_ERROR)) return true;
38370 if (jj_3R_234()) return true;
38371 if (jj_scan_token(CC_END)) return true;
38372 return false;
38373 }
38374
38375 private boolean jj_3R_615() {
38376 Token xsp;
38377 xsp = jj_scanpos;
38378 if (jj_3R_626()) {
38379 jj_scanpos = xsp;
38380 if (jj_3R_627()) return true;
38381 }
38382 return false;
38383 }
38384
38385 private boolean jj_3R_534() {
38386 if (jj_3R_323()) return true;
38387 return false;
38388 }
38389
38390 private boolean jj_3R_506() {
38391 Token xsp;
38392 xsp = jj_scanpos;
38393 if (jj_3R_534()) {
38394 jj_scanpos = xsp;
38395 if (jj_3R_535()) return true;
38396 }
38397 return false;
38398 }
38399
38400 private boolean jj_3R_474() {
38401 if (jj_scan_token(CC_ELSE)) return true;
38402 Token xsp;
38403 while (true) {
38404 xsp = jj_scanpos;
38405 if (jj_3R_506()) { jj_scanpos = xsp; break; }
38406 }
38407 return false;
38408 }
38409
38410 private boolean jj_3R_533() {
38411 if (jj_scan_token(CC_ERROR)) return true;
38412 if (jj_3R_234()) return true;
38413 if (jj_scan_token(CC_END)) return true;
38414 return false;
38415 }
38416
38417 private boolean jj_3R_532() {
38418 if (jj_3R_323()) return true;
38419 return false;
38420 }
38421
38422 private boolean jj_3R_505() {
38423 Token xsp;
38424 xsp = jj_scanpos;
38425 if (jj_3R_532()) {
38426 jj_scanpos = xsp;
38427 if (jj_3R_533()) return true;
38428 }
38429 return false;
38430 }
38431
38432 private boolean jj_3R_590() {
38433 if (jj_3R_615()) return true;
38434 return false;
38435 }
38436
38437 private boolean jj_3R_473() {
38438 if (jj_scan_token(CC_ELSIF)) return true;
38439 if (jj_3R_344()) return true;
38440 if (jj_scan_token(CC_THEN)) return true;
38441 Token xsp;
38442 while (true) {
38443 xsp = jj_scanpos;
38444 if (jj_3R_505()) { jj_scanpos = xsp; break; }
38445 }
38446 return false;
38447 }
38448
38449 private boolean jj_3R_589() {
38450 if (jj_scan_token(NOT)) return true;
38451 if (jj_3R_484()) return true;
38452 return false;
38453 }
38454
38455 private boolean jj_3R_504() {
38456 if (jj_scan_token(CC_ERROR)) return true;
38457 if (jj_3R_234()) return true;
38458 if (jj_scan_token(CC_END)) return true;
38459 return false;
38460 }
38461
38462 private boolean jj_3R_254() {
38463 if (jj_3R_124()) return true;
38464 return false;
38465 }
38466
38467 private boolean jj_3R_545() {
38468 Token xsp;
38469 xsp = jj_scanpos;
38470 if (jj_3R_589()) {
38471 jj_scanpos = xsp;
38472 if (jj_3R_590()) return true;
38473 }
38474 return false;
38475 }
38476
38477 private boolean jj_3R_503() {
38478 if (jj_3R_323()) return true;
38479 return false;
38480 }
38481
38482 private boolean jj_3R_472() {
38483 Token xsp;
38484 xsp = jj_scanpos;
38485 if (jj_3R_503()) {
38486 jj_scanpos = xsp;
38487 if (jj_3R_504()) return true;
38488 }
38489 return false;
38490 }
38491
38492 private boolean jj_3R_514() {
38493 if (jj_3R_545()) return true;
38494 return false;
38495 }
38496
38497 private boolean jj_3R_544() {
38498 if (jj_scan_token(17)) return true;
38499 return false;
38500 }
38501
38502 private boolean jj_3R_427() {
38503 if (jj_scan_token(CC_IF)) return true;
38504 if (jj_3R_344()) return true;
38505 if (jj_scan_token(CC_THEN)) return true;
38506 Token xsp;
38507 while (true) {
38508 xsp = jj_scanpos;
38509 if (jj_3R_472()) { jj_scanpos = xsp; break; }
38510 }
38511 while (true) {
38512 xsp = jj_scanpos;
38513 if (jj_3R_473()) { jj_scanpos = xsp; break; }
38514 }
38515 while (true) {
38516 xsp = jj_scanpos;
38517 if (jj_3R_474()) { jj_scanpos = xsp; break; }
38518 }
38519 if (jj_scan_token(CC_END)) return true;
38520 return false;
38521 }
38522
38523 private boolean jj_3R_543() {
38524 if (jj_scan_token(16)) return true;
38525 return false;
38526 }
38527
38528 private boolean jj_3R_275() {
38529 if (jj_3R_323()) return true;
38530 return false;
38531 }
38532
38533 private boolean jj_3R_513() {
38534 Token xsp;
38535 xsp = jj_scanpos;
38536 if (jj_3R_543()) {
38537 jj_scanpos = xsp;
38538 if (jj_3R_544()) return true;
38539 }
38540 if (jj_3R_484()) return true;
38541 return false;
38542 }
38543
38544 private boolean jj_3R_484() {
38545 Token xsp;
38546 xsp = jj_scanpos;
38547 if (jj_3R_513()) {
38548 jj_scanpos = xsp;
38549 if (jj_3R_514()) return true;
38550 }
38551 return false;
38552 }
38553
38554 private boolean jj_3R_385() {
38555 if (jj_3R_427()) return true;
38556 return false;
38557 }
38558
38559 private boolean jj_3R_192() {
38560 Token xsp;
38561 while (true) {
38562 xsp = jj_scanpos;
38563 if (jj_3R_275()) { jj_scanpos = xsp; break; }
38564 }
38565 return false;
38566 }
38567
38568 private boolean jj_3R_384() {
38569 if (jj_3R_426()) return true;
38570 return false;
38571 }
38572
38573 private boolean jj_3_18() {
38574 Token xsp;
38575 xsp = jj_scanpos;
38576 if (jj_scan_token(125)) {
38577 jj_scanpos = xsp;
38578 if (jj_scan_token(223)) return true;
38579 }
38580 if (jj_3R_120()) return true;
38581 return false;
38582 }
38583
38584 private boolean jj_3_17() {
38585 Token xsp;
38586 xsp = jj_scanpos;
38587 if (jj_scan_token(284)) {
38588 jj_scanpos = xsp;
38589 if (jj_scan_token(264)) return true;
38590 }
38591 if (jj_3R_120()) return true;
38592 xsp = jj_scanpos;
38593 if (jj_scan_token(152)) {
38594 jj_scanpos = xsp;
38595 if (jj_scan_token(51)) return true;
38596 }
38597 return false;
38598 }
38599
38600 private boolean jj_3R_608() {
38601 if (jj_scan_token(MOD)) return true;
38602 return false;
38603 }
38604
38605 private boolean jj_3R_383() {
38606 if (jj_3R_425()) return true;
38607 return false;
38608 }
38609
38610 private boolean jj_3R_607() {
38611 if (jj_scan_token(1)) return true;
38612 return false;
38613 }
38614
38615 private boolean jj_3R_382() {
38616 if (jj_3R_424()) return true;
38617 return false;
38618 }
38619
38620 private boolean jj_3R_606() {
38621 if (jj_scan_token(20)) return true;
38622 return false;
38623 }
38624
38625 private boolean jj_3R_605() {
38626 if (jj_scan_token(19)) return true;
38627 return false;
38628 }
38629
38630 private boolean jj_3_20() {
38631 if (jj_3R_122()) return true;
38632 return false;
38633 }
38634
38635 private boolean jj_3R_307() {
38636 if (jj_3R_351()) return true;
38637 return false;
38638 }
38639
38640 private boolean jj_3R_570() {
38641 Token xsp;
38642 xsp = jj_scanpos;
38643 if (jj_3R_605()) {
38644 jj_scanpos = xsp;
38645 if (jj_3R_606()) {
38646 jj_scanpos = xsp;
38647 if (jj_3R_607()) {
38648 jj_scanpos = xsp;
38649 if (jj_3R_608()) return true;
38650 }
38651 }
38652 }
38653 if (jj_3R_484()) return true;
38654 return false;
38655 }
38656
38657 private boolean jj_3_19() {
38658 if (jj_3R_121()) return true;
38659 return false;
38660 }
38661
38662 private boolean jj_3R_381() {
38663 if (jj_3R_118()) return true;
38664 return false;
38665 }
38666
38667 private boolean jj_3R_380() {
38668 if (jj_3R_153()) return true;
38669 return false;
38670 }
38671
38672 private boolean jj_3_16() {
38673 if (jj_3R_119()) return true;
38674 return false;
38675 }
38676
38677 private boolean jj_3R_379() {
38678 if (jj_3R_423()) return true;
38679 return false;
38680 }
38681
38682 private boolean jj_3R_537() {
38683 if (jj_3R_484()) return true;
38684 Token xsp;
38685 while (true) {
38686 xsp = jj_scanpos;
38687 if (jj_3R_570()) { jj_scanpos = xsp; break; }
38688 }
38689 return false;
38690 }
38691
38692 private boolean jj_3_15() {
38693 if (jj_3R_118()) return true;
38694 return false;
38695 }
38696
38697 private boolean jj_3R_252() {
38698 Token xsp;
38699 xsp = jj_scanpos;
38700 if (jj_scan_token(100)) {
38701 jj_scanpos = xsp;
38702 if (jj_scan_token(182)) return true;
38703 }
38704 return false;
38705 }
38706
38707 private boolean jj_3R_306() {
38708 if (jj_3R_174()) return true;
38709 return false;
38710 }
38711
38712 private boolean jj_3R_300() {
38713 if (jj_scan_token(18)) return true;
38714 if (jj_3R_133()) return true;
38715 return false;
38716 }
38717
38718 private boolean jj_3R_323() {
38719 Token xsp;
38720 xsp = jj_scanpos;
38721 if (jj_3R_379()) {
38722 jj_scanpos = xsp;
38723 if (jj_3_16()) {
38724 jj_scanpos = xsp;
38725 if (jj_3R_380()) {
38726 jj_scanpos = xsp;
38727 if (jj_3R_381()) {
38728 jj_scanpos = xsp;
38729 if (jj_3_19()) {
38730 jj_scanpos = xsp;
38731 if (jj_3_20()) {
38732 jj_scanpos = xsp;
38733 if (jj_3R_382()) {
38734 jj_scanpos = xsp;
38735 if (jj_3R_383()) {
38736 jj_scanpos = xsp;
38737 if (jj_3R_384()) {
38738 jj_scanpos = xsp;
38739 if (jj_3R_385()) return true;
38740 }
38741 }
38742 }
38743 }
38744 }
38745 }
38746 }
38747 }
38748 }
38749 return false;
38750 }
38751
38752 private boolean jj_3R_253() {
38753 if (jj_scan_token(BEGIN)) return true;
38754 Token xsp;
38755 while (true) {
38756 xsp = jj_scanpos;
38757 if (jj_3R_306()) { jj_scanpos = xsp; break; }
38758 }
38759 xsp = jj_scanpos;
38760 if (jj_3R_307()) jj_scanpos = xsp;
38761 return false;
38762 }
38763
38764 private boolean jj_3R_230() {
38765 if (jj_3R_133()) return true;
38766 Token xsp;
38767 while (true) {
38768 xsp = jj_scanpos;
38769 if (jj_3R_300()) { jj_scanpos = xsp; break; }
38770 }
38771 return false;
38772 }
38773
38774 private boolean jj_3R_251() {
38775 if (jj_scan_token(OR)) return true;
38776 if (jj_scan_token(REPLACE)) return true;
38777 return false;
38778 }
38779
38780 private boolean jj_3R_573() {
38781 if (jj_scan_token(18)) return true;
38782 return false;
38783 }
38784
38785 private boolean jj_3R_161() {
38786 Token xsp;
38787 xsp = jj_scanpos;
38788 if (jj_scan_token(152)) {
38789 jj_scanpos = xsp;
38790 if (jj_scan_token(51)) return true;
38791 }
38792 if (jj_3R_192()) return true;
38793 xsp = jj_scanpos;
38794 if (jj_3R_253()) jj_scanpos = xsp;
38795 if (jj_scan_token(END)) return true;
38796 xsp = jj_scanpos;
38797 if (jj_3R_254()) jj_scanpos = xsp;
38798 if (jj_scan_token(4)) return true;
38799 return false;
38800 }
38801
38802 private boolean jj_3R_572() {
38803 if (jj_scan_token(17)) return true;
38804 return false;
38805 }
38806
38807 private boolean jj_3R_571() {
38808 if (jj_scan_token(16)) return true;
38809 return false;
38810 }
38811
38812 private boolean jj_3R_538() {
38813 Token xsp;
38814 xsp = jj_scanpos;
38815 if (jj_3R_571()) {
38816 jj_scanpos = xsp;
38817 if (jj_3R_572()) {
38818 jj_scanpos = xsp;
38819 if (jj_3R_573()) return true;
38820 }
38821 }
38822 if (jj_3R_537()) return true;
38823 return false;
38824 }
38825
38826 private boolean jj_3R_160() {
38827 if (jj_3R_249()) return true;
38828 return false;
38829 }
38830
38831 private boolean jj_3R_271() {
38832 if (jj_3R_191()) return true;
38833 return false;
38834 }
38835
38836 private boolean jj_3R_159() {
38837 if (jj_scan_token(CREATE)) return true;
38838 Token xsp;
38839 xsp = jj_scanpos;
38840 if (jj_3R_251()) jj_scanpos = xsp;
38841 xsp = jj_scanpos;
38842 if (jj_3R_252()) jj_scanpos = xsp;
38843 return false;
38844 }
38845
38846 private boolean jj_3R_508() {
38847 if (jj_3R_537()) return true;
38848 Token xsp;
38849 while (true) {
38850 xsp = jj_scanpos;
38851 if (jj_3R_538()) { jj_scanpos = xsp; break; }
38852 }
38853 return false;
38854 }
38855
38856 private boolean jj_3R_588() {
38857 if (jj_3R_183()) return true;
38858 return false;
38859 }
38860
38861 private boolean jj_3R_246() {
38862 Token xsp;
38863 xsp = jj_scanpos;
38864 if (jj_scan_token(100)) {
38865 jj_scanpos = xsp;
38866 if (jj_scan_token(182)) return true;
38867 }
38868 return false;
38869 }
38870
38871 private boolean jj_3R_250() {
38872 if (jj_3R_124()) return true;
38873 return false;
38874 }
38875
38876 private boolean jj_3R_202() {
38877 if (jj_3R_283()) return true;
38878 return false;
38879 }
38880
38881 private boolean jj_3R_587() {
38882 if (jj_scan_token(CHARACTER_LITERAL)) return true;
38883 return false;
38884 }
38885
38886 private boolean jj_3R_104() {
38887 Token xsp;
38888 xsp = jj_scanpos;
38889 if (jj_3R_159()) jj_scanpos = xsp;
38890 xsp = jj_scanpos;
38891 if (jj_scan_token(209)) {
38892 jj_scanpos = xsp;
38893 if (jj_scan_token(284)) return true;
38894 }
38895 if (jj_scan_token(BODY)) return true;
38896 if (jj_3R_155()) return true;
38897 xsp = jj_scanpos;
38898 if (jj_3R_160()) {
38899 jj_scanpos = xsp;
38900 if (jj_3R_161()) return true;
38901 }
38902 return false;
38903 }
38904
38905 private boolean jj_3R_542() {
38906 if (jj_scan_token(ESCAPE)) return true;
38907 Token xsp;
38908 xsp = jj_scanpos;
38909 if (jj_3R_587()) {
38910 jj_scanpos = xsp;
38911 if (jj_3R_588()) return true;
38912 }
38913 return false;
38914 }
38915
38916 private boolean jj_3R_614() {
38917 if (jj_scan_token(ALL)) return true;
38918 return false;
38919 }
38920
38921 private boolean jj_3R_613() {
38922 if (jj_scan_token(DISTINCT)) return true;
38923 return false;
38924 }
38925
38926 private boolean jj_3R_586() {
38927 Token xsp;
38928 xsp = jj_scanpos;
38929 if (jj_3R_613()) {
38930 jj_scanpos = xsp;
38931 if (jj_3R_614()) return true;
38932 }
38933 return false;
38934 }
38935
38936 private boolean jj_3R_585() {
38937 if (jj_scan_token(UNION)) return true;
38938 return false;
38939 }
38940
38941 private boolean jj_3R_584() {
38942 if (jj_scan_token(INTERSECT)) return true;
38943 return false;
38944 }
38945
38946 private boolean jj_3R_124() {
38947 Token xsp;
38948 xsp = jj_scanpos;
38949 if (jj_scan_token(420)) {
38950 jj_scanpos = xsp;
38951 if (jj_scan_token(428)) {
38952 jj_scanpos = xsp;
38953 if (jj_3R_202()) {
38954 jj_scanpos = xsp;
38955 if (jj_scan_token(35)) {
38956 jj_scanpos = xsp;
38957 if (jj_scan_token(38)) {
38958 jj_scanpos = xsp;
38959 if (jj_scan_token(39)) {
38960 jj_scanpos = xsp;
38961 if (jj_scan_token(40)) {
38962 jj_scanpos = xsp;
38963 if (jj_scan_token(41)) {
38964 jj_scanpos = xsp;
38965 if (jj_scan_token(46)) {
38966 jj_scanpos = xsp;
38967 if (jj_scan_token(47)) {
38968 jj_scanpos = xsp;
38969 if (jj_scan_token(48)) {
38970 jj_scanpos = xsp;
38971 if (jj_scan_token(49)) {
38972 jj_scanpos = xsp;
38973 if (jj_scan_token(50)) {
38974 jj_scanpos = xsp;
38975 if (jj_scan_token(51)) {
38976 jj_scanpos = xsp;
38977 if (jj_scan_token(52)) {
38978 jj_scanpos = xsp;
38979 if (jj_scan_token(56)) {
38980 jj_scanpos = xsp;
38981 if (jj_scan_token(58)) {
38982 jj_scanpos = xsp;
38983 if (jj_scan_token(59)) {
38984 jj_scanpos = xsp;
38985 if (jj_scan_token(60)) {
38986 jj_scanpos = xsp;
38987 if (jj_scan_token(61)) {
38988 jj_scanpos = xsp;
38989 if (jj_scan_token(63)) {
38990 jj_scanpos = xsp;
38991 if (jj_scan_token(66)) {
38992 jj_scanpos = xsp;
38993 if (jj_scan_token(67)) {
38994 jj_scanpos = xsp;
38995 if (jj_scan_token(68)) {
38996 jj_scanpos = xsp;
38997 if (jj_scan_token(69)) {
38998 jj_scanpos = xsp;
38999 if (jj_scan_token(71)) {
39000 jj_scanpos = xsp;
39001 if (jj_scan_token(77)) {
39002 jj_scanpos = xsp;
39003 if (jj_scan_token(78)) {
39004 jj_scanpos = xsp;
39005 if (jj_scan_token(79)) {
39006 jj_scanpos = xsp;
39007 if (jj_scan_token(83)) {
39008 jj_scanpos = xsp;
39009 if (jj_scan_token(85)) {
39010 jj_scanpos = xsp;
39011 if (jj_scan_token(88)) {
39012 jj_scanpos = xsp;
39013 if (jj_scan_token(90)) {
39014 jj_scanpos = xsp;
39015 if (jj_scan_token(91)) {
39016 jj_scanpos = xsp;
39017 if (jj_scan_token(92)) {
39018 jj_scanpos = xsp;
39019 if (jj_scan_token(93)) {
39020 jj_scanpos = xsp;
39021 if (jj_scan_token(94)) {
39022 jj_scanpos = xsp;
39023 if (jj_scan_token(97)) {
39024 jj_scanpos = xsp;
39025 if (jj_scan_token(98)) {
39026 jj_scanpos = xsp;
39027 if (jj_scan_token(99)) {
39028 jj_scanpos = xsp;
39029 if (jj_scan_token(102)) {
39030 jj_scanpos = xsp;
39031 if (jj_scan_token(103)) {
39032 jj_scanpos = xsp;
39033 if (jj_scan_token(108)) {
39034 jj_scanpos = xsp;
39035 if (jj_scan_token(110)) {
39036 jj_scanpos = xsp;
39037 if (jj_scan_token(111)) {
39038 jj_scanpos = xsp;
39039 if (jj_scan_token(112)) {
39040 jj_scanpos = xsp;
39041 if (jj_scan_token(118)) {
39042 jj_scanpos = xsp;
39043 if (jj_scan_token(120)) {
39044 jj_scanpos = xsp;
39045 if (jj_scan_token(121)) {
39046 jj_scanpos = xsp;
39047 if (jj_scan_token(122)) {
39048 jj_scanpos = xsp;
39049 if (jj_scan_token(124)) {
39050 jj_scanpos = xsp;
39051 if (jj_scan_token(127)) {
39052 jj_scanpos = xsp;
39053 if (jj_scan_token(128)) {
39054 jj_scanpos = xsp;
39055 if (jj_scan_token(131)) {
39056 jj_scanpos = xsp;
39057 if (jj_scan_token(135)) {
39058 jj_scanpos = xsp;
39059 if (jj_scan_token(137)) {
39060 jj_scanpos = xsp;
39061 if (jj_scan_token(139)) {
39062 jj_scanpos = xsp;
39063 if (jj_scan_token(144)) {
39064 jj_scanpos = xsp;
39065 if (jj_scan_token(146)) {
39066 jj_scanpos = xsp;
39067 if (jj_scan_token(147)) {
39068 jj_scanpos = xsp;
39069 if (jj_scan_token(148)) {
39070 jj_scanpos = xsp;
39071 if (jj_scan_token(150)) {
39072 jj_scanpos = xsp;
39073 if (jj_scan_token(152)) {
39074 jj_scanpos = xsp;
39075 if (jj_scan_token(156)) {
39076 jj_scanpos = xsp;
39077 if (jj_scan_token(158)) {
39078 jj_scanpos = xsp;
39079 if (jj_scan_token(159)) {
39080 jj_scanpos = xsp;
39081 if (jj_scan_token(160)) {
39082 jj_scanpos = xsp;
39083 if (jj_scan_token(161)) {
39084 jj_scanpos = xsp;
39085 if (jj_scan_token(167)) {
39086 jj_scanpos = xsp;
39087 if (jj_scan_token(171)) {
39088 jj_scanpos = xsp;
39089 if (jj_scan_token(172)) {
39090 jj_scanpos = xsp;
39091 if (jj_scan_token(175)) {
39092 jj_scanpos = xsp;
39093 if (jj_scan_token(178)) {
39094 jj_scanpos = xsp;
39095 if (jj_scan_token(181)) {
39096 jj_scanpos = xsp;
39097 if (jj_scan_token(183)) {
39098 jj_scanpos = xsp;
39099 if (jj_scan_token(184)) {
39100 jj_scanpos = xsp;
39101 if (jj_scan_token(185)) {
39102 jj_scanpos = xsp;
39103 if (jj_scan_token(187)) {
39104 jj_scanpos = xsp;
39105 if (jj_scan_token(192)) {
39106 jj_scanpos = xsp;
39107 if (jj_scan_token(194)) {
39108 jj_scanpos = xsp;
39109 if (jj_scan_token(195)) {
39110 jj_scanpos = xsp;
39111 if (jj_scan_token(197)) {
39112 jj_scanpos = xsp;
39113 if (jj_scan_token(188)) {
39114 jj_scanpos = xsp;
39115 if (jj_scan_token(189)) {
39116 jj_scanpos = xsp;
39117 if (jj_scan_token(190)) {
39118 jj_scanpos = xsp;
39119 if (jj_scan_token(191)) {
39120 jj_scanpos = xsp;
39121 if (jj_scan_token(201)) {
39122 jj_scanpos = xsp;
39123 if (jj_scan_token(202)) {
39124 jj_scanpos = xsp;
39125 if (jj_scan_token(203)) {
39126 jj_scanpos = xsp;
39127 if (jj_scan_token(204)) {
39128 jj_scanpos = xsp;
39129 if (jj_scan_token(207)) {
39130 jj_scanpos = xsp;
39131 if (jj_scan_token(212)) {
39132 jj_scanpos = xsp;
39133 if (jj_scan_token(215)) {
39134 jj_scanpos = xsp;
39135 if (jj_scan_token(216)) {
39136 jj_scanpos = xsp;
39137 if (jj_scan_token(217)) {
39138 jj_scanpos = xsp;
39139 if (jj_scan_token(220)) {
39140 jj_scanpos = xsp;
39141 if (jj_scan_token(222)) {
39142 jj_scanpos = xsp;
39143 if (jj_scan_token(221)) {
39144 jj_scanpos = xsp;
39145 if (jj_scan_token(224)) {
39146 jj_scanpos = xsp;
39147 if (jj_scan_token(225)) {
39148 jj_scanpos = xsp;
39149 if (jj_scan_token(227)) {
39150 jj_scanpos = xsp;
39151 if (jj_scan_token(246)) {
39152 jj_scanpos = xsp;
39153 if (jj_scan_token(250)) {
39154 jj_scanpos = xsp;
39155 if (jj_scan_token(252)) {
39156 jj_scanpos = xsp;
39157 if (jj_scan_token(255)) {
39158 jj_scanpos = xsp;
39159 if (jj_scan_token(256)) {
39160 jj_scanpos = xsp;
39161 if (jj_scan_token(258)) {
39162 jj_scanpos = xsp;
39163 if (jj_scan_token(259)) {
39164 jj_scanpos = xsp;
39165 if (jj_scan_token(260)) {
39166 jj_scanpos = xsp;
39167 if (jj_scan_token(261)) {
39168 jj_scanpos = xsp;
39169 if (jj_scan_token(263)) {
39170 jj_scanpos = xsp;
39171 if (jj_scan_token(267)) {
39172 jj_scanpos = xsp;
39173 if (jj_scan_token(268)) {
39174 jj_scanpos = xsp;
39175 if (jj_scan_token(269)) {
39176 jj_scanpos = xsp;
39177 if (jj_scan_token(271)) {
39178 jj_scanpos = xsp;
39179 if (jj_scan_token(273)) {
39180 jj_scanpos = xsp;
39181 if (jj_scan_token(280)) {
39182 jj_scanpos = xsp;
39183 if (jj_scan_token(282)) {
39184 jj_scanpos = xsp;
39185 if (jj_scan_token(284)) {
39186 jj_scanpos = xsp;
39187 if (jj_scan_token(285)) {
39188 jj_scanpos = xsp;
39189 if (jj_scan_token(297)) {
39190 jj_scanpos = xsp;
39191 if (jj_scan_token(298)) {
39192 jj_scanpos = xsp;
39193 if (jj_scan_token(299)) {
39194 jj_scanpos = xsp;
39195 if (jj_scan_token(303)) {
39196 jj_scanpos = xsp;
39197 if (jj_scan_token(305)) {
39198 jj_scanpos = xsp;
39199 if (jj_scan_token(308)) {
39200 jj_scanpos = xsp;
39201 if (jj_scan_token(318)) {
39202 jj_scanpos = xsp;
39203 if (jj_scan_token(292)) {
39204 jj_scanpos = xsp;
39205 if (jj_scan_token(432)) {
39206 jj_scanpos = xsp;
39207 if (jj_scan_token(429)) {
39208 jj_scanpos = xsp;
39209 if (jj_scan_token(430)) {
39210 jj_scanpos = xsp;
39211 if (jj_scan_token(431)) return true;
39212 }
39213 }
39214 }
39215 }
39216 }
39217 }
39218 }
39219 }
39220 }
39221 }
39222 }
39223 }
39224 }
39225 }
39226 }
39227 }
39228 }
39229 }
39230 }
39231 }
39232 }
39233 }
39234 }
39235 }
39236 }
39237 }
39238 }
39239 }
39240 }
39241 }
39242 }
39243 }
39244 }
39245 }
39246 }
39247 }
39248 }
39249 }
39250 }
39251 }
39252 }
39253 }
39254 }
39255 }
39256 }
39257 }
39258 }
39259 }
39260 }
39261 }
39262 }
39263 }
39264 }
39265 }
39266 }
39267 }
39268 }
39269 }
39270 }
39271 }
39272 }
39273 }
39274 }
39275 }
39276 }
39277 }
39278 }
39279 }
39280 }
39281 }
39282 }
39283 }
39284 }
39285 }
39286 }
39287 }
39288 }
39289 }
39290 }
39291 }
39292 }
39293 }
39294 }
39295 }
39296 }
39297 }
39298 }
39299 }
39300 }
39301 }
39302 }
39303 }
39304 }
39305 }
39306 }
39307 }
39308 }
39309 }
39310 }
39311 }
39312 }
39313 }
39314 }
39315 }
39316 }
39317 }
39318 }
39319 }
39320 }
39321 }
39322 }
39323 }
39324 }
39325 }
39326 }
39327 }
39328 }
39329 }
39330 }
39331 }
39332 }
39333 }
39334 }
39335 }
39336 }
39337 }
39338 }
39339 }
39340 }
39341 }
39342 }
39343 return false;
39344 }
39345
39346 private boolean jj_3R_583() {
39347 if (jj_scan_token(EXCEPT)) return true;
39348 return false;
39349 }
39350
39351 private boolean jj_3R_158() {
39352 Token xsp;
39353 xsp = jj_scanpos;
39354 if (jj_scan_token(152)) {
39355 jj_scanpos = xsp;
39356 if (jj_scan_token(51)) return true;
39357 }
39358 if (jj_3R_192()) return true;
39359 if (jj_scan_token(END)) return true;
39360 xsp = jj_scanpos;
39361 if (jj_3R_250()) jj_scanpos = xsp;
39362 if (jj_scan_token(4)) return true;
39363 return false;
39364 }
39365
39366 private boolean jj_3R_157() {
39367 if (jj_3R_249()) return true;
39368 return false;
39369 }
39370
39371 private boolean jj_3R_245() {
39372 if (jj_scan_token(OR)) return true;
39373 if (jj_scan_token(REPLACE)) return true;
39374 return false;
39375 }
39376
39377 private boolean jj_3R_612() {
39378 if (jj_scan_token(OF)) return true;
39379 return false;
39380 }
39381
39382 private boolean jj_3R_248() {
39383 if (jj_3R_239()) return true;
39384 return false;
39385 }
39386
39387 private boolean jj_3R_541() {
39388 if (jj_scan_token(MULTISET)) return true;
39389 Token xsp;
39390 xsp = jj_scanpos;
39391 if (jj_3R_583()) {
39392 jj_scanpos = xsp;
39393 if (jj_3R_584()) {
39394 jj_scanpos = xsp;
39395 if (jj_3R_585()) return true;
39396 }
39397 }
39398 xsp = jj_scanpos;
39399 if (jj_3R_586()) jj_scanpos = xsp;
39400 return false;
39401 }
39402
39403 private boolean jj_3R_611() {
39404 if (jj_scan_token(SUBMULTISET)) return true;
39405 return false;
39406 }
39407
39408 private boolean jj_3R_156() {
39409 Token xsp;
39410 xsp = jj_scanpos;
39411 if (jj_3R_247()) {
39412 jj_scanpos = xsp;
39413 if (jj_3R_248()) return true;
39414 }
39415 return false;
39416 }
39417
39418 private boolean jj_3R_247() {
39419 if (jj_scan_token(AUTHID)) return true;
39420 Token xsp;
39421 xsp = jj_scanpos;
39422 if (jj_scan_token(37)) {
39423 jj_scanpos = xsp;
39424 if (jj_scan_token(36)) return true;
39425 }
39426 return false;
39427 }
39428
39429 private boolean jj_3R_610() {
39430 if (jj_scan_token(MEMBER)) return true;
39431 return false;
39432 }
39433
39434 private boolean jj_3R_154() {
39435 if (jj_scan_token(CREATE)) return true;
39436 Token xsp;
39437 xsp = jj_scanpos;
39438 if (jj_3R_245()) jj_scanpos = xsp;
39439 xsp = jj_scanpos;
39440 if (jj_3R_246()) jj_scanpos = xsp;
39441 return false;
39442 }
39443
39444 private boolean jj_3R_582() {
39445 Token xsp;
39446 xsp = jj_scanpos;
39447 if (jj_3R_610()) {
39448 jj_scanpos = xsp;
39449 if (jj_3R_611()) return true;
39450 }
39451 xsp = jj_scanpos;
39452 if (jj_3R_612()) jj_scanpos = xsp;
39453 return false;
39454 }
39455
39456 private boolean jj_3R_581() {
39457 if (jj_scan_token(FROM)) return true;
39458 return false;
39459 }
39460
39461 private boolean jj_3R_580() {
39462 if (jj_scan_token(LIKE)) return true;
39463 return false;
39464 }
39465
39466 private boolean jj_3R_103() {
39467 Token xsp;
39468 xsp = jj_scanpos;
39469 if (jj_3R_154()) jj_scanpos = xsp;
39470 if (jj_scan_token(PACKAGE)) return true;
39471 if (jj_3R_155()) return true;
39472 while (true) {
39473 xsp = jj_scanpos;
39474 if (jj_3R_156()) { jj_scanpos = xsp; break; }
39475 }
39476 xsp = jj_scanpos;
39477 if (jj_3R_157()) {
39478 jj_scanpos = xsp;
39479 if (jj_3R_158()) return true;
39480 }
39481 return false;
39482 }
39483
39484 private boolean jj_3R_579() {
39485 if (jj_scan_token(BETWEEN)) return true;
39486 return false;
39487 }
39488
39489 private boolean jj_3R_578() {
39490 if (jj_scan_token(IN)) return true;
39491 return false;
39492 }
39493
39494 private boolean jj_3R_609() {
39495 if (jj_scan_token(15)) return true;
39496 return false;
39497 }
39498
39499 private boolean jj_3R_577() {
39500 if (jj_scan_token(NOT)) return true;
39501 return false;
39502 }
39503
39504 private boolean jj_3R_576() {
39505 if (jj_scan_token(10)) return true;
39506 return false;
39507 }
39508
39509 private boolean jj_3R_575() {
39510 if (jj_scan_token(15)) return true;
39511 return false;
39512 }
39513
39514 private boolean jj_3R_117() {
39515 if (jj_scan_token(DECLARE)) return true;
39516 if (jj_3R_192()) return true;
39517 return false;
39518 }
39519
39520 private boolean jj_3R_540() {
39521 Token xsp;
39522 xsp = jj_scanpos;
39523 if (jj_3R_577()) jj_scanpos = xsp;
39524 xsp = jj_scanpos;
39525 if (jj_3R_578()) {
39526 jj_scanpos = xsp;
39527 if (jj_3R_579()) {
39528 jj_scanpos = xsp;
39529 if (jj_3R_580()) {
39530 jj_scanpos = xsp;
39531 if (jj_3R_581()) {
39532 jj_scanpos = xsp;
39533 if (jj_3R_582()) return true;
39534 }
39535 }
39536 }
39537 }
39538 return false;
39539 }
39540
39541 private boolean jj_3R_574() {
39542 if (jj_scan_token(14)) return true;
39543 Token xsp;
39544 xsp = jj_scanpos;
39545 if (jj_3R_609()) jj_scanpos = xsp;
39546 return false;
39547 }
39548
39549 private boolean jj_3R_322() {
39550 if (jj_3R_351()) return true;
39551 return false;
39552 }
39553
39554 private boolean jj_3R_321() {
39555 if (jj_3R_174()) return true;
39556 return false;
39557 }
39558
39559 private boolean jj_3R_539() {
39560 Token xsp;
39561 xsp = jj_scanpos;
39562 if (jj_3R_574()) {
39563 jj_scanpos = xsp;
39564 if (jj_3R_575()) return true;
39565 }
39566 xsp = jj_scanpos;
39567 if (jj_3R_576()) jj_scanpos = xsp;
39568 return false;
39569 }
39570
39571 private boolean jj_3R_116() {
39572 if (jj_3R_191()) return true;
39573 return false;
39574 }
39575
39576 private boolean jj_3_14() {
39577 Token xsp;
39578 while (true) {
39579 xsp = jj_scanpos;
39580 if (jj_3R_116()) { jj_scanpos = xsp; break; }
39581 }
39582 xsp = jj_scanpos;
39583 if (jj_3R_117()) jj_scanpos = xsp;
39584 if (jj_scan_token(BEGIN)) return true;
39585 return false;
39586 }
39587
39588 private boolean jj_3R_509() {
39589 Token xsp;
39590 xsp = jj_scanpos;
39591 if (jj_3R_539()) {
39592 jj_scanpos = xsp;
39593 if (jj_3R_540()) {
39594 jj_scanpos = xsp;
39595 if (jj_3R_541()) return true;
39596 }
39597 }
39598 if (jj_3R_508()) return true;
39599 xsp = jj_scanpos;
39600 if (jj_3R_542()) jj_scanpos = xsp;
39601 return false;
39602 }
39603
39604 private boolean jj_3R_320() {
39605 if (jj_scan_token(DECLARE)) return true;
39606 if (jj_3R_192()) return true;
39607 return false;
39608 }
39609
39610 private boolean jj_3R_272() {
39611 Token xsp;
39612 xsp = jj_scanpos;
39613 if (jj_3R_320()) jj_scanpos = xsp;
39614 if (jj_scan_token(BEGIN)) return true;
39615 while (true) {
39616 xsp = jj_scanpos;
39617 if (jj_3R_321()) { jj_scanpos = xsp; break; }
39618 }
39619 xsp = jj_scanpos;
39620 if (jj_3R_322()) jj_scanpos = xsp;
39621 if (jj_scan_token(END)) return true;
39622 xsp = jj_scanpos;
39623 if (jj_scan_token(420)) jj_scanpos = xsp;
39624 return false;
39625 }
39626
39627 private boolean jj_3R_482() {
39628 if (jj_3R_508()) return true;
39629 Token xsp;
39630 while (true) {
39631 xsp = jj_scanpos;
39632 if (jj_3R_509()) { jj_scanpos = xsp; break; }
39633 }
39634 return false;
39635 }
39636
39637 private boolean jj_3R_186() {
39638 Token xsp;
39639 while (true) {
39640 xsp = jj_scanpos;
39641 if (jj_3R_271()) { jj_scanpos = xsp; break; }
39642 }
39643 if (jj_3R_272()) return true;
39644 if (jj_scan_token(4)) return true;
39645 return false;
39646 }
39647
39648 private boolean jj_3R_512() {
39649 if (jj_scan_token(IS)) return true;
39650 return false;
39651 }
39652
39653 private boolean jj_3R_511() {
39654 if (jj_scan_token(13)) return true;
39655 if (jj_scan_token(10)) return true;
39656 return false;
39657 }
39658
39659 private boolean jj_3R_510() {
39660 if (jj_scan_token(10)) return true;
39661 return false;
39662 }
39663
39664 private boolean jj_3R_483() {
39665 Token xsp;
39666 xsp = jj_scanpos;
39667 if (jj_3R_510()) {
39668 jj_scanpos = xsp;
39669 if (jj_3R_511()) {
39670 jj_scanpos = xsp;
39671 if (jj_3R_512()) return true;
39672 }
39673 }
39674 if (jj_3R_482()) return true;
39675 return false;
39676 }
39677
39678 private boolean jj_3R_113() {
39679 Token xsp;
39680 xsp = jj_scanpos;
39681 if (jj_3R_186()) {
39682 jj_scanpos = xsp;
39683 if (jj_3_15()) return true;
39684 }
39685 return false;
39686 }
39687
39688 private boolean jj_3R_437() {
39689 if (jj_3R_482()) return true;
39690 Token xsp;
39691 while (true) {
39692 xsp = jj_scanpos;
39693 if (jj_3R_483()) { jj_scanpos = xsp; break; }
39694 }
39695 return false;
39696 }
39697
39698 private boolean jj_3R_438() {
39699 if (jj_scan_token(AND)) return true;
39700 if (jj_3R_437()) return true;
39701 return false;
39702 }
39703
39704 private boolean jj_3R_395() {
39705 if (jj_3R_437()) return true;
39706 Token xsp;
39707 while (true) {
39708 xsp = jj_scanpos;
39709 if (jj_3R_438()) { jj_scanpos = xsp; break; }
39710 }
39711 return false;
39712 }
39713
39714 private boolean jj_3R_396() {
39715 if (jj_scan_token(OR)) return true;
39716 if (jj_3R_395()) return true;
39717 return false;
39718 }
39719
39720 private boolean jj_3R_189() {
39721 if (jj_scan_token(3)) return true;
39722 if (jj_scan_token(ATTACH)) return true;
39723 return false;
39724 }
39725
39726 private boolean jj_3R_344() {
39727 if (jj_3R_395()) return true;
39728 Token xsp;
39729 while (true) {
39730 xsp = jj_scanpos;
39731 if (jj_3R_396()) { jj_scanpos = xsp; break; }
39732 }
39733 return false;
39734 }
39735
39736 private boolean jj_3R_237() {
39737 if (jj_scan_token(3)) return true;
39738 if (jj_3R_234()) return true;
39739 return false;
39740 }
39741
39742 private boolean jj_3R_235() {
39743 if (jj_scan_token(AT)) return true;
39744 if (jj_scan_token(TIME)) return true;
39745 if (jj_scan_token(ZONE)) return true;
39746 if (jj_3R_133()) return true;
39747 return false;
39748 }
39749
39750 private boolean jj_3R_140() {
39751 Token xsp;
39752 xsp = jj_scanpos;
39753 if (jj_scan_token(390)) {
39754 jj_scanpos = xsp;
39755 if (jj_scan_token(391)) return true;
39756 }
39757 if (jj_scan_token(5)) return true;
39758 if (jj_3R_234()) return true;
39759 xsp = jj_scanpos;
39760 if (jj_3R_235()) jj_scanpos = xsp;
39761 if (jj_scan_token(AS)) return true;
39762 if (jj_3R_236()) return true;
39763 if (jj_scan_token(7)) return true;
39764 while (true) {
39765 xsp = jj_scanpos;
39766 if (jj_3R_237()) { jj_scanpos = xsp; break; }
39767 }
39768 return false;
39769 }
39770
39771 private boolean jj_3R_229() {
39772 if (jj_3R_230()) return true;
39773 return false;
39774 }
39775
39776 private boolean jj_3R_228() {
39777 Token xsp;
39778 xsp = jj_scanpos;
39779 if (jj_scan_token(399)) {
39780 jj_scanpos = xsp;
39781 if (jj_scan_token(400)) {
39782 jj_scanpos = xsp;
39783 if (jj_scan_token(395)) return true;
39784 }
39785 }
39786 return false;
39787 }
39788
39789 private boolean jj_3R_115() {
39790 Token xsp;
39791 xsp = jj_scanpos;
39792 if (jj_scan_token(2)) {
39793 jj_scanpos = xsp;
39794 if (jj_scan_token(377)) {
39795 jj_scanpos = xsp;
39796 if (jj_scan_token(74)) {
39797 jj_scanpos = xsp;
39798 if (jj_scan_token(78)) {
39799 jj_scanpos = xsp;
39800 if (jj_scan_token(379)) {
39801 jj_scanpos = xsp;
39802 if (jj_scan_token(380)) {
39803 jj_scanpos = xsp;
39804 if (jj_scan_token(381)) {
39805 jj_scanpos = xsp;
39806 if (jj_scan_token(111)) {
39807 jj_scanpos = xsp;
39808 if (jj_scan_token(113)) {
39809 jj_scanpos = xsp;
39810 if (jj_scan_token(382)) {
39811 jj_scanpos = xsp;
39812 if (jj_scan_token(383)) {
39813 jj_scanpos = xsp;
39814 if (jj_scan_token(221)) {
39815 jj_scanpos = xsp;
39816 if (jj_scan_token(384)) {
39817 jj_scanpos = xsp;
39818 if (jj_scan_token(385)) {
39819 jj_scanpos = xsp;
39820 if (jj_scan_token(253)) {
39821 jj_scanpos = xsp;
39822 if (jj_scan_token(294)) {
39823 jj_scanpos = xsp;
39824 if (jj_scan_token(295)) {
39825 jj_scanpos = xsp;
39826 if (jj_scan_token(261)) {
39827 jj_scanpos = xsp;
39828 if (jj_scan_token(386)) {
39829 jj_scanpos = xsp;
39830 if (jj_scan_token(387)) {
39831 jj_scanpos = xsp;
39832 if (jj_scan_token(388)) {
39833 jj_scanpos = xsp;
39834 if (jj_scan_token(75)) {
39835 jj_scanpos = xsp;
39836 if (jj_scan_token(129)) {
39837 jj_scanpos = xsp;
39838 if (jj_scan_token(240)) {
39839 jj_scanpos = xsp;
39840 if (jj_scan_token(99)) {
39841 jj_scanpos = xsp;
39842 if (jj_scan_token(420)) {
39843 jj_scanpos = xsp;
39844 if (jj_3R_189()) return true;
39845 }
39846 }
39847 }
39848 }
39849 }
39850 }
39851 }
39852 }
39853 }
39854 }
39855 }
39856 }
39857 }
39858 }
39859 }
39860 }
39861 }
39862 }
39863 }
39864 }
39865 }
39866 }
39867 }
39868 }
39869 }
39870 }
39871 if (jj_3R_190()) return true;
39872 return false;
39873 }
39874
39875 private boolean jj_3R_138() {
39876 if (jj_scan_token(TRIM)) return true;
39877 if (jj_scan_token(5)) return true;
39878 Token xsp;
39879 xsp = jj_scanpos;
39880 if (jj_3R_228()) jj_scanpos = xsp;
39881 xsp = jj_scanpos;
39882 if (jj_3R_229()) jj_scanpos = xsp;
39883 if (jj_scan_token(FROM)) return true;
39884 if (jj_3R_230()) return true;
39885 if (jj_scan_token(7)) return true;
39886 return false;
39887 }
39888
39889 private boolean jj_3R_114() {
39890 if (jj_3R_187()) return true;
39891 if (jj_3R_188()) return true;
39892 return false;
39893 }
39894
39895 private boolean jj_3_13() {
39896 if (jj_3R_115()) return true;
39897 return false;
39898 }
39899
39900 private boolean jj_3_12() {
39901 if (jj_3R_114()) return true;
39902 return false;
39903 }
39904
39905 private boolean jj_3_11() {
39906 if (jj_3R_113()) return true;
39907 return false;
39908 }
39909
39910 private boolean jj_3_10() {
39911 if (jj_3R_112()) return true;
39912 return false;
39913 }
39914
39915 private boolean jj_3_9() {
39916 if (jj_3R_111()) return true;
39917 return false;
39918 }
39919
39920 private boolean jj_3_8() {
39921 if (jj_3R_110()) return true;
39922 return false;
39923 }
39924
39925 private boolean jj_3_7() {
39926 if (jj_3R_109()) return true;
39927 return false;
39928 }
39929
39930 private boolean jj_3_6() {
39931 if (jj_3R_108()) return true;
39932 return false;
39933 }
39934
39935 private boolean jj_3_5() {
39936 if (jj_3R_107()) return true;
39937 return false;
39938 }
39939
39940 private boolean jj_3_4() {
39941 if (jj_3R_106()) return true;
39942 return false;
39943 }
39944
39945 private boolean jj_3_3() {
39946 if (jj_3R_105()) return true;
39947 return false;
39948 }
39949
39950 private boolean jj_3_2() {
39951 if (jj_3R_104()) return true;
39952 return false;
39953 }
39954
39955 private boolean jj_3_1() {
39956 if (jj_3R_103()) return true;
39957 return false;
39958 }
39959
39960 private boolean jj_3R_233() {
39961 if (jj_scan_token(ELSE)) return true;
39962 if (jj_3R_234()) return true;
39963 return false;
39964 }
39965
39966 private boolean jj_3R_232() {
39967 if (jj_scan_token(WHEN)) return true;
39968 if (jj_3R_234()) return true;
39969 if (jj_scan_token(THEN)) return true;
39970 if (jj_3R_234()) return true;
39971 return false;
39972 }
39973
39974 private boolean jj_3R_231() {
39975 if (jj_3R_234()) return true;
39976 return false;
39977 }
39978
39979 private boolean jj_3R_139() {
39980 if (jj_scan_token(CASE)) return true;
39981 Token xsp;
39982 xsp = jj_scanpos;
39983 if (jj_3R_231()) jj_scanpos = xsp;
39984 if (jj_3R_232()) return true;
39985 while (true) {
39986 xsp = jj_scanpos;
39987 if (jj_3R_232()) { jj_scanpos = xsp; break; }
39988 }
39989 xsp = jj_scanpos;
39990 if (jj_3R_233()) jj_scanpos = xsp;
39991 if (jj_scan_token(END)) return true;
39992 return false;
39993 }
39994
39995 private boolean jj_3R_343() {
39996 if (jj_3R_133()) return true;
39997 if (jj_scan_token(9)) return true;
39998 if (jj_scan_token(10)) return true;
39999 if (jj_3R_234()) return true;
40000 return false;
40001 }
40002
40003 private boolean jj_3R_398() {
40004 if (jj_scan_token(CC_ELSE)) return true;
40005 if (jj_3R_234()) return true;
40006 return false;
40007 }
40008
40009 private boolean jj_3R_397() {
40010 if (jj_scan_token(CC_ELSIF)) return true;
40011 if (jj_3R_344()) return true;
40012 if (jj_scan_token(CC_THEN)) return true;
40013 if (jj_3R_234()) return true;
40014 return false;
40015 }
40016
40017 private boolean jj_3R_109() {
40018 if (jj_scan_token(ALTER)) return true;
40019 if (jj_scan_token(TRIGGER)) return true;
40020 if (jj_3R_180()) return true;
40021 if (jj_scan_token(4)) return true;
40022 return false;
40023 }
40024
40025 private boolean jj_3R_319() {
40026 if (jj_3R_378()) return true;
40027 return false;
40028 }
40029
40030 private boolean jj_3R_345() {
40031 if (jj_scan_token(CC_IF)) return true;
40032 if (jj_3R_344()) return true;
40033 if (jj_scan_token(CC_THEN)) return true;
40034 if (jj_3R_234()) return true;
40035 Token xsp;
40036 while (true) {
40037 xsp = jj_scanpos;
40038 if (jj_3R_397()) { jj_scanpos = xsp; break; }
40039 }
40040 while (true) {
40041 xsp = jj_scanpos;
40042 if (jj_3R_398()) { jj_scanpos = xsp; break; }
40043 }
40044 if (jj_scan_token(CC_END)) return true;
40045 return false;
40046 }
40047
40048 private boolean jj_3_45() {
40049 if (jj_3R_133()) return true;
40050 if (jj_scan_token(9)) return true;
40051 if (jj_scan_token(10)) return true;
40052 return false;
40053 }
40054
40055 private boolean jj_3R_318() {
40056 if (jj_3R_187()) return true;
40057 return false;
40058 }
40059
40060 private boolean jj_3R_268() {
40061 Token xsp;
40062 xsp = jj_scanpos;
40063 if (jj_3R_318()) {
40064 jj_scanpos = xsp;
40065 if (jj_3R_319()) return true;
40066 }
40067 return false;
40068 }
40069
40070 private boolean jj_3R_303() {
40071 if (jj_3R_345()) return true;
40072 return false;
40073 }
40074
40075 private boolean jj_3R_302() {
40076 if (jj_3R_344()) return true;
40077 return false;
40078 }
40079
40080 private boolean jj_3R_301() {
40081 if (jj_3R_343()) return true;
40082 return false;
40083 }
40084
40085 private boolean jj_3R_234() {
40086 Token xsp;
40087 xsp = jj_scanpos;
40088 if (jj_3R_301()) {
40089 jj_scanpos = xsp;
40090 if (jj_3R_302()) {
40091 jj_scanpos = xsp;
40092 if (jj_3R_303()) return true;
40093 }
40094 }
40095 return false;
40096 }
40097
40098 private boolean jj_3R_378() {
40099 Token xsp;
40100 xsp = jj_scanpos;
40101 if (jj_scan_token(361)) {
40102 jj_scanpos = xsp;
40103 if (jj_scan_token(360)) {
40104 jj_scanpos = xsp;
40105 if (jj_scan_token(355)) {
40106 jj_scanpos = xsp;
40107 if (jj_scan_token(354)) {
40108 jj_scanpos = xsp;
40109 if (jj_scan_token(359)) {
40110 jj_scanpos = xsp;
40111 if (jj_scan_token(364)) return true;
40112 }
40113 }
40114 }
40115 }
40116 }
40117 return false;
40118 }
40119
40120 private boolean jj_3R_274() {
40121 if (jj_scan_token(DISASSOCIATE)) return true;
40122 if (jj_scan_token(STATISTICS)) return true;
40123 return false;
40124 }
40125
40126 private boolean jj_3_85() {
40127 if (jj_3R_124()) return true;
40128 if (jj_scan_token(3)) return true;
40129 return false;
40130 }
40131
40132 private boolean jj_3R_273() {
40133 if (jj_scan_token(ASSOCIATE)) return true;
40134 if (jj_scan_token(STATISTICS)) return true;
40135 return false;
40136 }
40137
40138 private boolean jj_3R_187() {
40139 Token xsp;
40140 xsp = jj_scanpos;
40141 if (jj_scan_token(47)) {
40142 jj_scanpos = xsp;
40143 if (jj_scan_token(344)) {
40144 jj_scanpos = xsp;
40145 if (jj_3R_273()) {
40146 jj_scanpos = xsp;
40147 if (jj_scan_token(346)) {
40148 jj_scanpos = xsp;
40149 if (jj_scan_token(75)) {
40150 jj_scanpos = xsp;
40151 if (jj_scan_token(83)) {
40152 jj_scanpos = xsp;
40153 if (jj_3R_274()) {
40154 jj_scanpos = xsp;
40155 if (jj_scan_token(99)) {
40156 jj_scanpos = xsp;
40157 if (jj_scan_token(129)) {
40158 jj_scanpos = xsp;
40159 if (jj_scan_token(357)) {
40160 jj_scanpos = xsp;
40161 if (jj_scan_token(233)) {
40162 jj_scanpos = xsp;
40163 if (jj_scan_token(240)) {
40164 jj_scanpos = xsp;
40165 if (jj_scan_token(365)) {
40166 jj_scanpos = xsp;
40167 if (jj_scan_token(350)) return true;
40168 }
40169 }
40170 }
40171 }
40172 }
40173 }
40174 }
40175 }
40176 }
40177 }
40178 }
40179 }
40180 }
40181 return false;
40182 }
40183
40184 private boolean jj_3R_424() {
40185 if (jj_3R_199()) return true;
40186 return false;
40187 }
40188
40189 private boolean jj_3R_122() {
40190 if (jj_3R_199()) return true;
40191 return false;
40192 }
40193
40194 private boolean jj_3R_502() {
40195 if (jj_scan_token(IS)) return true;
40196 Token xsp;
40197 while (true) {
40198 xsp = jj_scanpos;
40199 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
40200 }
40201 if (jj_3R_405()) return true;
40202 return false;
40203 }
40204
40205 private boolean jj_3R_501() {
40206 if (jj_scan_token(RETURN)) return true;
40207 if (jj_3R_236()) return true;
40208 return false;
40209 }
40210
40211 private boolean jj_3R_500() {
40212 if (jj_3R_386()) return true;
40213 return false;
40214 }
40215
40216 private boolean jj_3_80() {
40217 if (jj_3R_124()) return true;
40218 if (jj_scan_token(3)) return true;
40219 return false;
40220 }
40221
40222 private boolean jj_3R_199() {
40223 if (jj_scan_token(CURSOR)) return true;
40224 if (jj_3R_124()) return true;
40225 Token xsp;
40226 xsp = jj_scanpos;
40227 if (jj_3R_500()) jj_scanpos = xsp;
40228 xsp = jj_scanpos;
40229 if (jj_3R_501()) jj_scanpos = xsp;
40230 xsp = jj_scanpos;
40231 if (jj_3R_502()) jj_scanpos = xsp;
40232 if (jj_scan_token(4)) return true;
40233 return false;
40234 }
40235
40236 private boolean jj_3_84() {
40237 if (jj_3R_122()) return true;
40238 return false;
40239 }
40240
40241 private boolean jj_3R_270() {
40242 if (jj_3R_268()) return true;
40243 return false;
40244 }
40245
40246 private boolean jj_3_83() {
40247 if (jj_3R_121()) return true;
40248 return false;
40249 }
40250
40251 private boolean jj_3_82() {
40252 if (jj_3R_153()) return true;
40253 return false;
40254 }
40255
40256 private boolean jj_3_81() {
40257 if (jj_3R_119()) return true;
40258 return false;
40259 }
40260
40261 private boolean jj_3R_177() {
40262 if (jj_3R_268()) return true;
40263 return false;
40264 }
40265
40266 private boolean jj_3R_563() {
40267 if (jj_3R_183()) return true;
40268 return false;
40269 }
40270
40271 private boolean jj_3R_633() {
40272 if (jj_3R_183()) return true;
40273 return false;
40274 }
40275
40276 private boolean jj_3R_152() {
40277 if (jj_scan_token(6)) return true;
40278 if (jj_3R_124()) return true;
40279 return false;
40280 }
40281
40282 private boolean jj_3R_562() {
40283 if (jj_3R_183()) return true;
40284 return false;
40285 }
40286
40287 private boolean jj_3R_151() {
40288 if (jj_scan_token(6)) return true;
40289 if (jj_3R_124()) return true;
40290 return false;
40291 }
40292
40293 private boolean jj_3R_425() {
40294 if (jj_scan_token(IDENTIFIER)) return true;
40295 return false;
40296 }
40297
40298 private boolean jj_3_76() {
40299 if (jj_3R_124()) return true;
40300 if (jj_scan_token(3)) return true;
40301 return false;
40302 }
40303
40304 private boolean jj_3_79() {
40305 if (jj_3R_124()) return true;
40306 if (jj_scan_token(3)) return true;
40307 return false;
40308 }
40309
40310 private boolean jj_3_75() {
40311 if (jj_scan_token(OF)) return true;
40312 if (jj_3R_124()) return true;
40313 Token xsp;
40314 while (true) {
40315 xsp = jj_scanpos;
40316 if (jj_3R_152()) { jj_scanpos = xsp; break; }
40317 }
40318 return false;
40319 }
40320
40321 private boolean jj_3_74() {
40322 if (jj_scan_token(OF)) return true;
40323 if (jj_3R_124()) return true;
40324 Token xsp;
40325 while (true) {
40326 xsp = jj_scanpos;
40327 if (jj_3R_151()) { jj_scanpos = xsp; break; }
40328 }
40329 return false;
40330 }
40331
40332 private boolean jj_3R_630() {
40333 if (jj_scan_token(3)) return true;
40334 Token xsp;
40335 xsp = jj_scanpos;
40336 if (jj_scan_token(420)) {
40337 jj_scanpos = xsp;
40338 if (jj_scan_token(428)) {
40339 jj_scanpos = xsp;
40340 if (jj_3R_633()) return true;
40341 }
40342 }
40343 return false;
40344 }
40345
40346 private boolean jj_3R_599() {
40347 if (jj_scan_token(9)) return true;
40348 if (jj_scan_token(10)) return true;
40349 return false;
40350 }
40351
40352 private boolean jj_3R_290() {
40353 if (jj_scan_token(PARAMETERS)) return true;
40354 if (jj_3R_564()) return true;
40355 return false;
40356 }
40357
40358 private boolean jj_3R_566() {
40359 Token xsp;
40360 xsp = jj_scanpos;
40361 if (jj_3R_599()) {
40362 jj_scanpos = xsp;
40363 if (jj_scan_token(92)) return true;
40364 }
40365 if (jj_3R_234()) return true;
40366 return false;
40367 }
40368
40369 private boolean jj_3R_526() {
40370 if (jj_scan_token(5)) return true;
40371 if (jj_3R_127()) return true;
40372 if (jj_scan_token(7)) return true;
40373 return false;
40374 }
40375
40376 private boolean jj_3R_289() {
40377 if (jj_scan_token(WITH)) return true;
40378 if (jj_scan_token(CONTEXT)) return true;
40379 return false;
40380 }
40381
40382 private boolean jj_3R_288() {
40383 if (jj_scan_token(NAME)) return true;
40384 Token xsp;
40385 xsp = jj_scanpos;
40386 if (jj_scan_token(420)) {
40387 jj_scanpos = xsp;
40388 if (jj_scan_token(428)) {
40389 jj_scanpos = xsp;
40390 if (jj_3R_563()) return true;
40391 }
40392 }
40393 return false;
40394 }
40395
40396 private boolean jj_3R_267() {
40397 Token xsp;
40398 xsp = jj_scanpos;
40399 if (jj_scan_token(100)) {
40400 jj_scanpos = xsp;
40401 if (jj_scan_token(182)) return true;
40402 }
40403 return false;
40404 }
40405
40406 private boolean jj_3R_528() {
40407 if (jj_scan_token(INDEX)) return true;
40408 if (jj_scan_token(BY)) return true;
40409 if (jj_3R_236()) return true;
40410 return false;
40411 }
40412
40413 private boolean jj_3R_524() {
40414 if (jj_scan_token(6)) return true;
40415 if (jj_3R_522()) return true;
40416 return false;
40417 }
40418
40419 private boolean jj_3R_201() {
40420 Token xsp;
40421 xsp = jj_scanpos;
40422 if (jj_3R_287()) {
40423 jj_scanpos = xsp;
40424 if (jj_3R_288()) {
40425 jj_scanpos = xsp;
40426 if (jj_3R_289()) {
40427 jj_scanpos = xsp;
40428 if (jj_3R_290()) return true;
40429 }
40430 }
40431 }
40432 return false;
40433 }
40434
40435 private boolean jj_3R_287() {
40436 if (jj_scan_token(LIBRARY)) return true;
40437 Token xsp;
40438 xsp = jj_scanpos;
40439 if (jj_scan_token(420)) {
40440 jj_scanpos = xsp;
40441 if (jj_scan_token(428)) {
40442 jj_scanpos = xsp;
40443 if (jj_3R_562()) return true;
40444 }
40445 }
40446 xsp = jj_scanpos;
40447 if (jj_3R_630()) jj_scanpos = xsp;
40448 return false;
40449 }
40450
40451 private boolean jj_3R_523() {
40452 if (jj_scan_token(6)) return true;
40453 if (jj_3R_522()) return true;
40454 return false;
40455 }
40456
40457
40458 public PLSQLParserTokenManager token_source;
40459 SimpleCharStream jj_input_stream;
40460
40461 public Token token;
40462
40463 public Token jj_nt;
40464 private Token jj_scanpos, jj_lastpos;
40465 private int jj_la;
40466 private int jj_gen;
40467 final private int[] jj_la1 = new int[460];
40468 static private int[] jj_la1_0;
40469 static private int[] jj_la1_1;
40470 static private int[] jj_la1_2;
40471 static private int[] jj_la1_3;
40472 static private int[] jj_la1_4;
40473 static private int[] jj_la1_5;
40474 static private int[] jj_la1_6;
40475 static private int[] jj_la1_7;
40476 static private int[] jj_la1_8;
40477 static private int[] jj_la1_9;
40478 static private int[] jj_la1_10;
40479 static private int[] jj_la1_11;
40480 static private int[] jj_la1_12;
40481 static private int[] jj_la1_13;
40482 static {
40483 jj_la1_init_0();
40484 jj_la1_init_1();
40485 jj_la1_init_2();
40486 jj_la1_init_3();
40487 jj_la1_init_4();
40488 jj_la1_init_5();
40489 jj_la1_init_6();
40490 jj_la1_init_7();
40491 jj_la1_init_8();
40492 jj_la1_init_9();
40493 jj_la1_init_10();
40494 jj_la1_init_11();
40495 jj_la1_init_12();
40496 jj_la1_init_13();
40497 }
40498 private static void jj_la1_init_0() {
40499 jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x0,0x20,0x0,0x0,0x0,0x40,0x0,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
40500 }
40501 private static void jj_la1_init_1() {
40502 jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
40503 }
40504 private static void jj_la1_init_2() {
40505 jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
40506 }
40507 private static void jj_la1_init_3() {
40508 jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
40509 }
40510 private static void jj_la1_init_4() {
40511 jj_la1_4 = new int[] {0x80010002,0x80010000,0x80010000,0x0,0x2,0x0,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x1000000,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x1000000,0x0,0x20000,0xffffdbbd,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x1000000,0x200,0x200,0x2ea6d134,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0x0,0x80010000,0x0,0x2ea2d1b4,0xaea3d1b4,0x0,0x2ea2d134,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x1000,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x600,0x600,0x0,0x600,0x600,0x0,0x0,0x0,0x0,0x20000000,0x0,0x400000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x2ea6d134,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x2ea2d134,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x10000200,0x100000,0x0,0x0,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x2ea2d134,0x0,0x200000,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x2eaad134,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x4000,0x4000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffdbbd,0xffffdbbd,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20020000,0x20020000,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x0,0xffffdbbd,0x0,0x20000,0x0,0x20000,0x2000,0x0,0x2000,0x0,0x0,0x800000,0x800000,0xffffdbbd,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10002,0x0,0x10000,0x0,0x10002,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x0,0x0,0xffffdbbd,0x0,0x2,0x0,0x2,0xffffdbbd,0x2,0x0,0x2,0x91550a4b,0x2ea2d134,0xffffdbbd,0x2ea2d134,0x2eaed134,0x240020,0x0,};
40512 }
40513 private static void jj_la1_init_5() {
40514 jj_la1_5 = new int[] {0x20,0x20,0x20,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0x800014,0xffedffff,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x0,0x0,0xfc49ef7f,0x0,0x0,0x800014,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf800c001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2100,0x2100,0x0,0x2100,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x20,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x4496f7e,0x0,0x4496f7e,0x0,0x4496f7e,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x800000,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0xfc49ef7f,0x0,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64b6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x800000,0x10,0x0,0x10,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x6cb6f7e,0x6cb6f7e,0x800000,0x64b6f7e,0x800000,0x0,0x0,0x0,0x0,0x64b6f7e,0x6496f7e,0x64b6f7e,0x0,0x2000000,0x4496f7e,0x0,0x6cb6f7e,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2800000,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x4,0x4,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0xffedffff,0x0,0x800014,0x0,0x0,0x2800000,0x800000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x0,0x800014,0x800014,0x0,0x0,0x0,0x800014,0x800014,0x400,0x0,0x0,0x0,0xffedffff,0x0,0xffedffff,0x0,0x2800000,0x800000,0x2000000,0x800000,0x800000,0x800000,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0xb901081,0x449677c,0xffedffff,0x4496f7e,0xfc6def7f,0xf800e201,0x0,};
40515 }
40516 private static void jj_la1_init_6() {
40517 jj_la1_6 = new int[] {0xa0020000,0x0,0x0,0x0,0x20000000,0x0,0x0,0xcc2b6392,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x800,0x0,0x0,0x0,0x20000,0x0,0xcc2b6392,0x0,0x0,0xfb9bffbf,0x0,0x4000000,0x80011000,0xff9bffbf,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x800,0x0,0x0,0x0,0x440000,0x0,0x0,0x0,0x0,0x0,0x1000,0xfb9bffbf,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x440000,0x0,0x0,0x4000000,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x440000,0x8000,0x0,0xcb8b6393,0x0,0x0,0x80011000,0x0,0x0,0x0,0x80000000,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0x0,0xc80b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x8000,0x8000,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcb8b6393,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x40,0x0,0x40,0xc80b6392,0xc80b6392,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x1000,0x0,0x1000,0x80020000,0x80020000,0x0,0x80020000,0x80020000,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x800,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x200,0x200,0x0,0x10000,0x0,0x10000,0x1000,0x1000,0x0,0x0,0x40000,0x400000,0x0,0x0,0x0,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff9bffbf,0xff9bffbf,0x0,0x11000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0x0,0xff9bffbf,0x4000000,0x80000000,0xfb9bffbf,0x0,0x0,0x800,0x0,0xfb9bffbf,0x0,0x0,0x0,0x10101c28,0x880b6192,0xfb9bffbf,0xc80b6392,0xff8be397,0x3800005,0x0,};
40518 }
40519 private static void jj_la1_init_7() {
40520 jj_la1_7 = new int[] {0x25030200,0x5020000,0x5020000,0x0,0x20010000,0x0,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x1000,0x0,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x1000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100008,0x100058,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x25020000,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x2fbeebfc,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x0,0x8000,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x2fbeebfc,0x800000,0x2fbeebfc,0x2bbeebfc,0x0,0x2bbeebfc,0x0,0x2bbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x6000,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x2fbeebfc,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x2bbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x2bbeebfc,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x2bbeebfc,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10200,0x0,0x0,0x0,0x10200,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0xbffeebff,0x0,0x10200,0x0,0x10200,0xbffeebff,0x10200,0x0,0x10200,0xe4010409,0x2bbeebf4,0xbffeebff,0x2bbeebfc,0x3bfeebfe,0x22740078,0x0,};
40521 }
40522 private static void jj_la1_init_8() {
40523 jj_la1_8 = new int[] {0x14000020,0x0,0x0,0x0,0x20,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x40,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675f,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x5afd675e,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x4001,0xc0000,0x0,0x0,0x0,0x0,0x1000000,0x80000,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x5afde75f,0x10000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x10000000,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x8080000,0x5afd675e,0x0,0x5afd675e,0x40000,0x0,0x8080000,0x8000000,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x14000000,0x14000000,0x0,0x14000000,0x14000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x7fffffff,0x7fffffff,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x85029021,0x4afd4742,0x7fffffff,0x5afd675e,0x7efd7fdb,0xfc8001,0x0,};
40524 }
40525 private static void jj_la1_init_9() {
40526 jj_la1_9 = new int[] {0x400002c0,0x40000200,0x40000200,0x0,0xc0,0x0,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0x0,0xffffff71,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xffffff71,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0xc3c0c00,0xf3fbc00,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x10000000,0x10000000,0x20000000,0x10000000,0x40000000,0x40000000,0x0,0xfffdf371,0xfffdf371,0x4,0x40000200,0x0,0xfffdf171,0xfffdf371,0x0,0xfffdf161,0x4,0x0,0x0,0xfffdf371,0xfffdf371,0xfffdf371,0xfffdf371,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x2,0x0,0xfffdf163,0x0,0xfffdf161,0xbffdf161,0x4,0xbffdf161,0x4,0xbffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0xfffdf161,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0xfffdf161,0x0,0x0,0xbffdf161,0x0,0xfffdf161,0x20000000,0x0,0x0,0x0,0x100,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x1,0xffffff71,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0xbffdf161,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x40000e0a,0xbfed7161,0xffffff71,0xbffdf161,0xbffffd71,0xff7ffc00,0x0,};
40527 }
40528 private static void jj_la1_init_10() {
40529 jj_la1_10 = new int[] {0xc7000000,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0xff0000c7,0x0,0x0,0x400,0xff0004c7,0xff0084c7,0xff0084c7,0x2000,0xff0084c7,0xff0084c7,0x1000,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0xff0000c7,0x2000,0x1000,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0xff0004c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0xff0004c7,0xff0000c7,0x0,0xff0000c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x2000,0xff0084c7,0x1000,0xff0084c7,0x8400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x2000,0x1000,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0xff0000c7,0x0,0x0,0xff0000c7,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0xc7000000,0x0,0x0,0x0,0xc7000000,0x10000000,0xff0000c7,0xc0,0xc0,0x20,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0xe,0x0,0xff0084c7,0xe,0x0,0xff0000cf,0xe,0x0,0xff0000c7,0x6,0xc7000000,0x0,0xc7000000,0xff0000c7,0xc7000000,0x0,0xc7000000,0x300,0xff0000c7,0xff0000c7,0xff0000c7,0xff0000c7,0x1,0x0,};
40530 }
40531 private static void jj_la1_init_11() {
40532 jj_la1_11 = new int[] {0xfa002020,0x0,0x0,0x0,0xfa000000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000000,0x0,0xffffffff,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x4000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x4004000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33ac,0x0,0x0,0x0,0x33ac,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x401,0xffffffff,0x0,0x401,0xffffffff,0x0,0x0,0xffffffff,0x0,0x33ac,0x0,0x33ac,0xffffffff,0x2020,0x138c,0x33ac,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x4000000,0x0,};
40533 }
40534 private static void jj_la1_init_12() {
40535 jj_la1_12 = new int[] {0x1f,0x0,0x0,0x0,0x1f,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x18800,0x18800,0x1fc7ffff,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1fc7ffff,0x0,0x0,0x60000,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x100000,0x100000,0x300000,0x80000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,};
40536 }
40537 private static void jj_la1_init_13() {
40538 jj_la1_13 = new int[] {0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x1630,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x0,0x10,0x1f010,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x10,0x1630,0x1630,0x1630,0x1630,0x10,0x0,0x0,0x1630,0x10,0x1630,0x10,0x1630,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x1010,0x0,0x1010,0x0,0x1010,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x1410,0x1410,0x0,0x1410,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1630,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x1630,0x0,0x620,0x1010,0x0,0x1630,0x0,0x0,0x620,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1410,0x1410,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x10,0x1f010,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1010,0x1010,0x1e000,0xe000,};
40539 }
40540 final private JJCalls[] jj_2_rtns = new JJCalls[85];
40541 private boolean jj_rescan = false;
40542 private int jj_gc = 0;
40543
40544
40545 public PLSQLParser(java.io.InputStream stream) {
40546 this(stream, null);
40547 }
40548
40549 public PLSQLParser(java.io.InputStream stream, String encoding) {
40550 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40551 token_source = new PLSQLParserTokenManager(jj_input_stream);
40552 token = new Token();
40553 token.next = jj_nt = token_source.getNextToken();
40554 jj_gen = 0;
40555 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40556 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40557 }
40558
40559
40560 public void ReInit(java.io.InputStream stream) {
40561 ReInit(stream, null);
40562 }
40563
40564 public void ReInit(java.io.InputStream stream, String encoding) {
40565 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40566 token_source.ReInit(jj_input_stream);
40567 token = new Token();
40568 token.next = jj_nt = token_source.getNextToken();
40569 jjtree.reset();
40570 jj_gen = 0;
40571 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40572 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40573 }
40574
40575
40576 public PLSQLParser(java.io.Reader stream) {
40577 jj_input_stream = new SimpleCharStream(stream, 1, 1);
40578 token_source = new PLSQLParserTokenManager(jj_input_stream);
40579 token = new Token();
40580 token.next = jj_nt = token_source.getNextToken();
40581 jj_gen = 0;
40582 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40583 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40584 }
40585
40586
40587 public void ReInit(java.io.Reader stream) {
40588 jj_input_stream.ReInit(stream, 1, 1);
40589 token_source.ReInit(jj_input_stream);
40590 token = new Token();
40591 token.next = jj_nt = token_source.getNextToken();
40592 jjtree.reset();
40593 jj_gen = 0;
40594 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40595 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40596 }
40597
40598
40599 public PLSQLParser(PLSQLParserTokenManager tm) {
40600 token_source = tm;
40601 token = new Token();
40602 token.next = jj_nt = token_source.getNextToken();
40603 jj_gen = 0;
40604 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40605 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40606 }
40607
40608
40609 public void ReInit(PLSQLParserTokenManager tm) {
40610 token_source = tm;
40611 token = new Token();
40612 token.next = jj_nt = token_source.getNextToken();
40613 jjtree.reset();
40614 jj_gen = 0;
40615 for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40616 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40617 }
40618
40619 private Token jj_consume_token(int kind) throws ParseException {
40620 Token oldToken = token;
40621 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40622 else jj_nt = jj_nt.next = token_source.getNextToken();
40623 if (token.kind == kind) {
40624 jj_gen++;
40625 if (++jj_gc > 100) {
40626 jj_gc = 0;
40627 for (int i = 0; i < jj_2_rtns.length; i++) {
40628 JJCalls c = jj_2_rtns[i];
40629 while (c != null) {
40630 if (c.gen < jj_gen) c.first = null;
40631 c = c.next;
40632 }
40633 }
40634 }
40635 return token;
40636 }
40637 jj_nt = token;
40638 token = oldToken;
40639 jj_kind = kind;
40640 throw generateParseException();
40641 }
40642
40643 static private final class LookaheadSuccess extends java.lang.Error { }
40644 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
40645 private boolean jj_scan_token(int kind) {
40646 if (jj_scanpos == jj_lastpos) {
40647 jj_la--;
40648 if (jj_scanpos.next == null) {
40649 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
40650 } else {
40651 jj_lastpos = jj_scanpos = jj_scanpos.next;
40652 }
40653 } else {
40654 jj_scanpos = jj_scanpos.next;
40655 }
40656 if (jj_rescan) {
40657 int i = 0; Token tok = token;
40658 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
40659 if (tok != null) jj_add_error_token(kind, i);
40660 }
40661 if (jj_scanpos.kind != kind) return true;
40662 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
40663 return false;
40664 }
40665
40666
40667
40668 final public Token getNextToken() {
40669 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40670 else jj_nt = jj_nt.next = token_source.getNextToken();
40671 jj_gen++;
40672 return token;
40673 }
40674
40675
40676 final public Token getToken(int index) {
40677 Token t = token;
40678 for (int i = 0; i < index; i++) {
40679 if (t.next != null) t = t.next;
40680 else t = t.next = token_source.getNextToken();
40681 }
40682 return t;
40683 }
40684
40685 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
40686 private int[] jj_expentry;
40687 private int jj_kind = -1;
40688 private int[] jj_lasttokens = new int[100];
40689 private int jj_endpos;
40690
40691 private void jj_add_error_token(int kind, int pos) {
40692 if (pos >= 100) return;
40693 if (pos == jj_endpos + 1) {
40694 jj_lasttokens[jj_endpos++] = kind;
40695 } else if (jj_endpos != 0) {
40696 jj_expentry = new int[jj_endpos];
40697 for (int i = 0; i < jj_endpos; i++) {
40698 jj_expentry[i] = jj_lasttokens[i];
40699 }
40700 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
40701 int[] oldentry = (int[])(it.next());
40702 if (oldentry.length == jj_expentry.length) {
40703 for (int i = 0; i < jj_expentry.length; i++) {
40704 if (oldentry[i] != jj_expentry[i]) {
40705 continue jj_entries_loop;
40706 }
40707 }
40708 jj_expentries.add(jj_expentry);
40709 break jj_entries_loop;
40710 }
40711 }
40712 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
40713 }
40714 }
40715
40716
40717 public ParseException generateParseException() {
40718 jj_expentries.clear();
40719 boolean[] la1tokens = new boolean[434];
40720 if (jj_kind >= 0) {
40721 la1tokens[jj_kind] = true;
40722 jj_kind = -1;
40723 }
40724 for (int i = 0; i < 460; i++) {
40725 if (jj_la1[i] == jj_gen) {
40726 for (int j = 0; j < 32; j++) {
40727 if ((jj_la1_0[i] & (1<<j)) != 0) {
40728 la1tokens[j] = true;
40729 }
40730 if ((jj_la1_1[i] & (1<<j)) != 0) {
40731 la1tokens[32+j] = true;
40732 }
40733 if ((jj_la1_2[i] & (1<<j)) != 0) {
40734 la1tokens[64+j] = true;
40735 }
40736 if ((jj_la1_3[i] & (1<<j)) != 0) {
40737 la1tokens[96+j] = true;
40738 }
40739 if ((jj_la1_4[i] & (1<<j)) != 0) {
40740 la1tokens[128+j] = true;
40741 }
40742 if ((jj_la1_5[i] & (1<<j)) != 0) {
40743 la1tokens[160+j] = true;
40744 }
40745 if ((jj_la1_6[i] & (1<<j)) != 0) {
40746 la1tokens[192+j] = true;
40747 }
40748 if ((jj_la1_7[i] & (1<<j)) != 0) {
40749 la1tokens[224+j] = true;
40750 }
40751 if ((jj_la1_8[i] & (1<<j)) != 0) {
40752 la1tokens[256+j] = true;
40753 }
40754 if ((jj_la1_9[i] & (1<<j)) != 0) {
40755 la1tokens[288+j] = true;
40756 }
40757 if ((jj_la1_10[i] & (1<<j)) != 0) {
40758 la1tokens[320+j] = true;
40759 }
40760 if ((jj_la1_11[i] & (1<<j)) != 0) {
40761 la1tokens[352+j] = true;
40762 }
40763 if ((jj_la1_12[i] & (1<<j)) != 0) {
40764 la1tokens[384+j] = true;
40765 }
40766 if ((jj_la1_13[i] & (1<<j)) != 0) {
40767 la1tokens[416+j] = true;
40768 }
40769 }
40770 }
40771 }
40772 for (int i = 0; i < 434; i++) {
40773 if (la1tokens[i]) {
40774 jj_expentry = new int[1];
40775 jj_expentry[0] = i;
40776 jj_expentries.add(jj_expentry);
40777 }
40778 }
40779 jj_endpos = 0;
40780 jj_rescan_token();
40781 jj_add_error_token(0, 0);
40782 int[][] exptokseq = new int[jj_expentries.size()][];
40783 for (int i = 0; i < jj_expentries.size(); i++) {
40784 exptokseq[i] = jj_expentries.get(i);
40785 }
40786 return new ParseException(token, exptokseq, tokenImage);
40787 }
40788
40789
40790 final public void enable_tracing() {
40791 }
40792
40793
40794 final public void disable_tracing() {
40795 }
40796
40797 private void jj_rescan_token() {
40798 jj_rescan = true;
40799 for (int i = 0; i < 85; i++) {
40800 try {
40801 JJCalls p = jj_2_rtns[i];
40802 do {
40803 if (p.gen > jj_gen) {
40804 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
40805 switch (i) {
40806 case 0: jj_3_1(); break;
40807 case 1: jj_3_2(); break;
40808 case 2: jj_3_3(); break;
40809 case 3: jj_3_4(); break;
40810 case 4: jj_3_5(); break;
40811 case 5: jj_3_6(); break;
40812 case 6: jj_3_7(); break;
40813 case 7: jj_3_8(); break;
40814 case 8: jj_3_9(); break;
40815 case 9: jj_3_10(); break;
40816 case 10: jj_3_11(); break;
40817 case 11: jj_3_12(); break;
40818 case 12: jj_3_13(); break;
40819 case 13: jj_3_14(); break;
40820 case 14: jj_3_15(); break;
40821 case 15: jj_3_16(); break;
40822 case 16: jj_3_17(); break;
40823 case 17: jj_3_18(); break;
40824 case 18: jj_3_19(); break;
40825 case 19: jj_3_20(); break;
40826 case 20: jj_3_21(); break;
40827 case 21: jj_3_22(); break;
40828 case 22: jj_3_23(); break;
40829 case 23: jj_3_24(); break;
40830 case 24: jj_3_25(); break;
40831 case 25: jj_3_26(); break;
40832 case 26: jj_3_27(); break;
40833 case 27: jj_3_28(); break;
40834 case 28: jj_3_29(); break;
40835 case 29: jj_3_30(); break;
40836 case 30: jj_3_31(); break;
40837 case 31: jj_3_32(); break;
40838 case 32: jj_3_33(); break;
40839 case 33: jj_3_34(); break;
40840 case 34: jj_3_35(); break;
40841 case 35: jj_3_36(); break;
40842 case 36: jj_3_37(); break;
40843 case 37: jj_3_38(); break;
40844 case 38: jj_3_39(); break;
40845 case 39: jj_3_40(); break;
40846 case 40: jj_3_41(); break;
40847 case 41: jj_3_42(); break;
40848 case 42: jj_3_43(); break;
40849 case 43: jj_3_44(); break;
40850 case 44: jj_3_45(); break;
40851 case 45: jj_3_46(); break;
40852 case 46: jj_3_47(); break;
40853 case 47: jj_3_48(); break;
40854 case 48: jj_3_49(); break;
40855 case 49: jj_3_50(); break;
40856 case 50: jj_3_51(); break;
40857 case 51: jj_3_52(); break;
40858 case 52: jj_3_53(); break;
40859 case 53: jj_3_54(); break;
40860 case 54: jj_3_55(); break;
40861 case 55: jj_3_56(); break;
40862 case 56: jj_3_57(); break;
40863 case 57: jj_3_58(); break;
40864 case 58: jj_3_59(); break;
40865 case 59: jj_3_60(); break;
40866 case 60: jj_3_61(); break;
40867 case 61: jj_3_62(); break;
40868 case 62: jj_3_63(); break;
40869 case 63: jj_3_64(); break;
40870 case 64: jj_3_65(); break;
40871 case 65: jj_3_66(); break;
40872 case 66: jj_3_67(); break;
40873 case 67: jj_3_68(); break;
40874 case 68: jj_3_69(); break;
40875 case 69: jj_3_70(); break;
40876 case 70: jj_3_71(); break;
40877 case 71: jj_3_72(); break;
40878 case 72: jj_3_73(); break;
40879 case 73: jj_3_74(); break;
40880 case 74: jj_3_75(); break;
40881 case 75: jj_3_76(); break;
40882 case 76: jj_3_77(); break;
40883 case 77: jj_3_78(); break;
40884 case 78: jj_3_79(); break;
40885 case 79: jj_3_80(); break;
40886 case 80: jj_3_81(); break;
40887 case 81: jj_3_82(); break;
40888 case 82: jj_3_83(); break;
40889 case 83: jj_3_84(); break;
40890 case 84: jj_3_85(); break;
40891 }
40892 }
40893 p = p.next;
40894 } while (p != null);
40895 } catch(LookaheadSuccess ls) { }
40896 }
40897 jj_rescan = false;
40898 }
40899
40900 private void jj_save(int index, int xla) {
40901 JJCalls p = jj_2_rtns[index];
40902 while (p.gen > jj_gen) {
40903 if (p.next == null) { p = p.next = new JJCalls(); break; }
40904 p = p.next;
40905 }
40906 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40907 }
40908
40909 static final class JJCalls {
40910 int gen;
40911 Token first;
40912 int arg;
40913 JJCalls next;
40914 }
40915
40916 }